Abstract: To produce high quality object-oriented (OO) applications, a strong emphasis on design aspects, especially during the early phases of software development, is necessary. Design metrics play an important role in helping developers understand design aspects of software and, hence, improve software quality and developer productivity. In this paper, we provide empirical evidence supporting the role of OO design complexity metrics, specifically a subset of the Chidamber and Kemerer (1991, 1994) suite (CK metrics), in determining software defects. Our results, based on industry data from software developed in two popular programming languages used in OO development, indicate that, even after controlling for the size of the software, these metrics are significantly associated with defects. In addition, we find that the effects of these metrics on defects vary across the samples from two programming languages-C++ and Java. We believe that these results have significant implications for designing high-quality software products using the OO approach.

Abstract: Software systems emerge from mere keystrokes to form intricate functional networks connecting many collaborating modules, objects, classes, methods, and subroutines. Building on recent advances in the study of complex networks, I have examined software collaboration graphs contained within several open-source software systems, and have found them to reveal scale-free, small-world networks similar to those identified in other technological, sociological, and biological systems. I present several measures of these network topologies, and discuss their relationship to software engineering practices. I also present a simple model of software system evolution based on refactoring processes which captures some of the salient features of the observed systems. Some implications of object-oriented design for questions about network robustness, evolvability, degeneracy, and organization are discussed in the wake of these findings.

Abstract: Reverse engineering software systems has become a major concern in software industry because of their sheer size and complexity. This problem needs to be tackled since the systems in question are of considerable worth to their owners and maintainers. In this article, we present the concept of a polymetric view, a lightweight software visualization technique enriched with software metrics information. Polymetric views help to understand the structure and detect problems of a software system in the initial phases of a reverse engineering process. We discuss the benefits and limits of several predefined polymetric views we have implemented in our tool CodeCrawler. Moreover, based on clusters of different polymetric views, we have developed a methodology which supports and guides a software engineer in the first phases of a reverse engineering of a large software system. We have refined this methodology by repeatedly applying it on industrial systems and illustrate it by applying a selection of polymetric views to a case study.

Abstract: The Common Optimization INterface for Operations Research (COIN-OR, http://www.coin-or.org/) is an initiative to promote open-source software for the operations research (OR) community. In OR practice and research, software is fundamental. The dependence of OR on software implies that the ways in which software is developed, managed, and distributed can have a significant impact on the field. Open source is a relatively new software development and distribution model which offers advantages over current practices. Its viability depends on the precise definition of open source, on the culture of a distributed developer community, and on a version-control system which makes distributed development possible. In this paper, we review open-source philosophy and culture, and present the goals and status of COIN-OR.

Abstract: Currently, the focus is on determining how to blend agile methodologies with plan-driven approaches to software development.

Abstract: A newcomer to a software project must typically come up-to-speed on a large, varied amount of information about the project before becoming productive. Assimilating this information in the open-source context is difficult because a newcomer cannot rely on the mentoring approach that is commonly used in traditional software developments. To help a newcomer to an open-source project become productive faster, we propose Hipikat, a tool that forms an implicit group memory from the information stored in a project's archives, and that recommends artifacts from the archives that are relevant to a task that a newcomer is trying to perform. To investigate this approach, we have instantiated the Hipikat tool for the Eclipse open-source project. In this paper, we describe the Hipikat tool, we report on a qualitative study conducted with a Hipikat mock-up on a medium-sized in-house project, and we report on a case study in which Hipikat recommendations were evaluated for a task on Eclipse.

Abstract: Software engineering is a human task, and as such we must study what software engineers do and think. Understanding the normative practice of software engineering is the first step toward developing realistic solutions to better facilitate the engineering process. We conducted three studies using several data-gathering approaches to elucidate the patterns by which software engineers (SEs) use and update documentation. Our objective is to more accurately comprehend and model documentation use, usefulness, and maintenance, thus enabling better decision making and tool design by developers and project managers. Our results confirm the widely held belief that SEs typically do not update documentation as timely or completely as software process personnel and managers advocate. However, the results also reveal that out-of-date software documentation remains useful in many circumstances.

Abstract: Software quality assurance (SQA) is becoming increasingly important to the software and electronics industries as software systems become more complex and integrative. This book is designed to serve the three audiences who will be facing the SQA challenge: students at universities and colleges, participants in vocational training courses and software development and maintenance practitioners/professionals.

Abstract: Little contemporary data exists for document actual practices of software professionals for software requirements elicitation, requirements specification, document development, and specification validation. This exploratory survey and its quantitative results offer opportunities for further interpretation and comparison.

Abstract: Anyone working on a software system with exacting requirements for scalability and user responsiveness will understand this book’s importance. Performance Solutions: A Practical Guide to Creating Responsive, Scalable Software speaks to practitioners, showing them how they can achieve system performances that meet user requirements, which are frequently overlooked until it is too late to do anything about them. Software performance engineering deals with software system performance and scalability. This book speaks to SPE’s importance in a seven-part treatise, starting with the motivation for SPE, then introducing the methodology and tools (including models for distributed systems), data collection, performance-oriented design (patterns, antipatterns, and performance tuning), applications and their models, and the SPE process and implementation strategies. The book ends with a ready reference for UML notations and SPE modeling notations. In the past, the art of performance engineering has been practiced by a select few who were charged with delivering mission-critical systems, and was highly specialized. Now we are realizing, as Paul Clements says in the book’s foreword, that all software systems have performance requirements and that it is important to pay attention to the system we are conceptualizing. The motivation for SPE is tremendous in mission-critical systems where safety is involved. But even for business systems such as an e-commerce Web site, performance could mean the difference between doing well and going under. Many horror stories from the dot-com era can attest to this, in which Web applications simply failed to keep up with the demand. Some practitioners have the wisdom to acknowledge performance constraints as part of the system’s quality attributes (this comes only from building many systems and actually deploying and supporting them in the real world), but others can find help in this book. The first part of the book does a good job of introducing the motivation for and a quick overview of SPE. It also discusses how to use the Unified Modeling Language as a basis for including performance information, thus integrating the performance aspect tightly into the software development process. Case studies include an interactive system (ICAD), a distributed system (an electronic virtual storefront), enhancement to an existing Web-based application, and an embedded realtime system (telephony switching). The authors emphasize starting with SPE early in the software development process when you are first conceptualizing a system. In practice, I believe such early adoption of SPE happens for systems that have safety as the overriding quality attribute. Those producing commercial software are either trying to keep costs down or rushing a product to market, so that the effort spent on such detailed performance engineering is virtually not there. For those entities, even getting their architect educated on performance-oriented design, performance patterns and antipatterns, and implementation solutions will go a long way toward building successful systems. Using the performance principles advocated in this book and conducting performance reviews of designs, code, and the integrated system will also be helpful. Although you could use this book as the basis of a graduate-level course, you’d have to add some exercises. These could be extensions of the case studies presented, since they make a number of simplifying assumptions. A software implementation project with exacting performance requirements could be part of the exercises. Today, systems are being built more often from COTS (commercial-off-theshelf) software. Applying SPE analysis to such systems as part of the evaluation would avoid nasty surprises. Any software manager would welcome a chapter devoted to this topic. Even if you cannot afford to implement a complete SPE process, this book provides enough knowledge to avoid performance disasters.

Abstract: Invasive software composition (ISC) composes software components by program transformation. Standard composition treats components as immutable blackboxes and plugs them together as they are. Invasive software composition goes one step further and transforms components when they are embedded in a reuse context. In this way, components can be adapted more appropriately to reuse requirements. The components need not be adapted by hand, instead invasive composition operators do all the work.

Abstract: Part I Introduction: introduction to software components testing software components introductions to component-based software testing component-based software. Part II Validation methods for software components: black-box testing methods for software components white-box testing methods for software components test automation and tools for software components. Part III Validation methods for component-based programs: integration testing for component-based software regression testing for component-based software performance testing and measurement frameworks for testing component-based software. Part IV Quality assurance for software components and component-based software: quality assurance for software components quality assurance for component-based software systems standards and certification for software components and component-based software component quality verification and measurement verification of quality for component-based software.

Abstract: Software reliability growth models (SRGMs) have been developed to estimate software reliability measures such as the number of remaining faults, software failure rate, and software reliability. Issues such as imperfect debugging and the learning phenomenon of developers have been considered in these models. However, most SRGMs assume that faults detected during tests will eventually be removed. Consideration of fault removal efficiency in the existing models is limited. In practice, fault removal efficiency is usually imperfect. This paper aims to incorporate fault removal efficiency into software reliability assessment. Fault removal efficiency is a useful metric in software development practice and it helps developers to evaluate the debugging effectiveness and estimate the additional workload. In this paper, imperfect debugging is considered in the sense that new faults can be introduced into the software during debugging and the detected faults may not be removed completely. A model is proposed to integrate fault removal efficiency, failure rate, and fault introduction rate into software reliability assessment. In addition to traditional reliability measures, the proposed model can provide some useful metrics to help the development team make better decisions. Software testing data collected from real applications are utilized to illustrate the proposed model for both the descriptive and predictive power. The expected number of residual faults and software failure rate are also presented.

Abstract: Software visualization is concerned with the static visualization as well as the animation of software artifacts, such as source code, executable programs, and the data they manipulate, and their attributes, such as size, complexity, or dependencies. Software visualization techniques are widely used in the areas of software maintenance, reverse engineering, and re-engineering, where typically large amounts of complex data need to be understood and a high degree of interaction between software engineers and automatic analyses is required. This paper reports the results of a survey on the perspectives of 82 researchers in software maintenance, reverse engineering, and re-engineering on software visualization. It describes to which degree the researchers are involved in software visualization themselves, what is visualized and how, whether animation is frequently used, whether the researchers believe animation is useful at all, which automatic graph layouts are used if at all, whether the layout algorithms have deficiencies, and--last but not least--where the medium-term and long-term research in software visualization should be directed. The results of this survey help to ascertain the current role of software visualization in software engineering from the perspective of researchers in these domains and give hints on future research avenues.

Abstract: Patterns provide a mechanism for rendering design advice in a reference format. Software design is a massive topic, and when faced with a design problem, one must be able to focus on something as close to the problem as you can get. Patterns can help by trying to identify common solutions to recurring problems. The solution is really what the pattern is, yet the problem is a vital part of the context. Patterns are half-balled - meaning one always have to finish them oneself and adapt them to ones own environment.

Abstract: The Object-Oriented (OO) paradigm has become increasingly popular in recent years. Researchers agree that, although maintenance may turn out to be easier for OO systems, it is unlikely that the maintenance burden will completely disappear. One approach to controlling software maintenance costs is the utilization of software metrics during the development phase, to help identify potential problem areas. Many new metrics have been proposed for OO systems, but only a few of them have been validated. The purpose of this research is to empirically explore the validation of three existing OO design complexity metrics and, specifically, to assess their ability to predict maintenance time. This research reports the results of validating three metrics, Interaction Level (IL), Interface Size (IS), and Operation Argument Complexity (OAC). A controlled experiment was conducted to investigate the effect of design complexity (as measured by the above metrics) on maintenance time. Each of the three metrics by itself was found to be useful in the experiment in predicting maintenance performance.

Abstract: This paper provides an overview of the author's Ph.D. thesis (2002). The primary contribution of this research involved developing techniques to extract architectural information about a system directly from its source code. To accomplish this objective a series of software clustering algorithms were developed. These algorithms use metaheuristic search techniques to partition a directed graph generated from the entities and relations in the source code into subsystems. Determining the optimal solution to this problem was shown to be NP-hard, thus significant emphasis was placed on finding solutions that were regarded as "good enough" quickly. Several evaluation techniques were developed to gauge solution quality, and all of the software clustering tools created to support this work was made available for download over the Internet.

Abstract: Test designers widely believe that the overall effectiveness and cost of software testing depends largely on the type and number of test cases executed on the software. In this paper we show that the test oracle used during testing also contributes significantly to test effectiveness and cost. A test oracle is a mechanism that determines whether a software executed correctly for a test case. We define a test oracle to contain two essential parts: oracle information that represents expected output, and an oracle procedure that compares the oracle information with the actual output. By varying the level of detail of oracle information and changing the oracle procedure, a test designer can create different types of test oracles. We design 11 types of test oracles and empirically compare them on four software systems. We seed faults in each software to create 100 faulty versions, execute 600 test cases on each version, for all 11 types of oracles. In all, we report results of 660,000 test runs on each software. We show (1) the time and space requirements of the oracles, (2) that faults are detected early in the testing process when using detailed oracle information and complex oracle procedures, although at a higher cost per test case, and (3) that employing expensive oracles results in detecting a large number of faults using relatively smaller number of test cases.

Abstract: Sandmark is a tool that measures the effectiveness of software-based methods for protecting software from piracy, tampering, and reverse engineering. The Sandmark team's goal is to develop techniques that will let users determine empirically which algorithms have the least performance overhead and the highest resilience to attacks.

Abstract: This book synthesizes and distills information so that the practicing software architect, and especially the beginning software architect, can fill in the gaps in their understanding of software architecture design.

Abstract: In one embodiment, the present invention is a method for automatically preventing errors in computer software. The method includes storing the computer software in a code repository; executing a plurality of software verification tools to verify the computer software, wherein each of the plurality of software verification tools automatically generates one or more test cases; generating verification results responsive to executing the plurality of software verification tools and the automatically generated test cases; processing the verification results for generating an objective criterion of quality of the computer software; and customizing the scope of one or more of the plurality of verification tools responsive to the objective criterion of quality of the computer software.

Abstract: The knowledge required to develop complex software has historically existed in programming folklore, the heads of experienced developers, or buried deep in the code. These locations are not ideal since the effort required to capture and evolve this knowledge is expensive, time-consuming, and error-prone. Many popular software modeling methods and tools address certain aspects of these problems by documenting how a system is designed However they only support limited portions of software development and do not articulate why a system is designed in a particular way, which complicates subsequent software reuse and evolution. Patterns, frameworks, and middleware are increasingly popular techniques for addressing key aspects of the challenges outlined above. Patterns codify reusable design expertise that provides time-proven solutions to commonly occurring software problems that arise in particular contexts and domains. Frameworks provide both a reusable product-line architecture [1] - guided by patterns - for a family of related applications and an integrated set of collaborating components that implement concrete realizations of the architecture. Middleware is reusable software that leverages patterns and frameworks to bridge the gap between the functional requirements of applications and the underlying operating systems, network protocol stacks, and databases. This paper presents an overview of patterns, frameworks, and middleware, describes how these technologies complement each other to enhance reuse and productivity, and then illustrates how they have been applied successfully in practice to improve the reusability and quality of complex software systems.

Abstract: A software license compliance system and method limits multiple access to a software program. License compliance software is associated with the software program which selectively prevents access to that software program. Each time a user accesses the software program the license compliance software accesses a remotely located database by means of a computer network or other connection to obtain a current unique validation code unique to that specific copy of the software program. If the code received from the database matches a current unique validation code stored in association with the software license compliance software on the user's computer the license compliance software permits the user to access and use the software program. A new unique validation code is generated and stored in the remotely located database as well in association with the license compliance software which replaces the current unique validation code which no longer functions to provide user access to the software program.

Abstract: A 2002 survey found that many companies use software reviews unsystematically, creating a mismatch between expected outcomes and review implementations. This suggests that many software practitioners understand basic review concepts but often fall to exploit their full potential.

Abstract: Software customization has been argued to benefit both the productivity of software engineers and end users. However, most customization methods rely on specialists to manually tweak individual applications for a specific user group. Existing software development methods also fail to acknowledge the importance of different kinds of user skills and preferences and how these might be incorporated into a customizable software design. We propose a framework for performing requirements analysis on user goals, skills, and preferences in order to generate a customizable software design. We illustrate our methodology with an email system and review an on-going case study involving users with traumatic brain injury.

Abstract: Software development is difficult because software is complex, the software production process is complex and understanding of software systems is a challenge. We propose a 3D visual approach to depict software production cost related program information to support software maintenance. The information helps us to reduce software maintenance costs, to plan the use of personnel wisely, to appoint experts efficiently and to detect system problems early.