Abstract: Software reuse is the process of creating software systems from existing software rather than building software systems from scratch. This simple yet powerful vision was introduced in 1968. Software reuse has, however, failed to become a standard software engineering practice. In an attempt to understand why, researchers have renewed their interest in software reuse and in the obstacles to implementing it.This paper surveys the different approaches to software reuse found in the research literature. It uses a taxonomy to describe and compare the different approaches and make generalizations about the field of software reuse. The taxonomy characterizes each reuse approach in terms of its reusable artifacts and the way these artifacts are abstracted, selected, specialized, and integrated.Abstraction plays a central role in software reuse. Concise and expressive abstractions are essential if software artifacts are to be effectively reused. The effectiveness of a reuse technique can be evaluated in terms of cognitive distance—an intuitive gauge of the intellectual effort required to use the technique. Cognitive distance is reduced in two ways: (1) Higher level abstractions in a reuse technique reduce the effort required to go from the initial concept of a software system to representations in the reuse technique, and (2) automation reduces the effort required to go from abstractions in a reuse technique to an executable implementation.This survey will help answer the following questions: What is software reuse? Why reuse software? What are the different approaches to reusing software? How effective are the different approaches? What is required to implement a software reuse technology? Why is software reuse difficult? What are the open areas for research in software reuse?

Abstract: A software radio is defined as a set of digital signal processing (DSP) primitives, a metalevel system for combining the primitives into communication system functions (transmitter, channel model, receiver, etc.), and a set of target processors on which the software radio is hosted for real-time communications. The performance of enabling hardware technologies is related to software radio requirements, portending a decade of shift from hardware radios toward software intensive approaches. Computational models and architecture are discussed, stressing the need for topological consistency of radio functions and host architectures. A layered topology-oriented design approach encapsulated in a canonical open architecture software radio model is presented. The model provides a unified mathematical framework for quantitative analysis of algorithm structures, host architectures, and system performance for CAD. >

Abstract: The paper gives an overview of the state of the art of software cost estimation (SCE). The main questions to be answered in the paper are: (1) What are the reasons for overruns of budgets and planned durations? (2) What are the prerequisites for estimating? (3) How can software development effort be estimated? (4) What can software project management expect from SCE models, how accurate are estimations which are made using these kind of models, and what are the pros and cons of cost estimation models?

Abstract: For Introduction to Programming (CS1) and other more intermediate courses covering programming in C++. Also appropriate as a supplement for upper-level courses where the instructor uses a book as a reference for the C++ language. This best-selling comprehensive text is aimed at readers with little or no programming experience. It teaches programming by presenting the concepts in the context of full working programs and takes an early-objects approach. The authors emphasize achieving program clarity through structured and object-oriented programming, software reuse and component-oriented software construction. The Eighth Edition encourages students to connect computers to the community, using the Internet to solve problems and make a difference in our world. All content has been carefully fine-tuned in response to a team of distinguished academic and industry reviewers.

Abstract: : This report presents guidelines for defining, recording, and reporting two frequently used measures of software size-physical source lines and logical source statements. We propose a general framework for constructing size definitions and use it to derive operational methods can be applied to address the information needs of different users while maintaining a common definition of software size. Software metrics, Software size, Software measure, Software measurement, Lines of code, LOC, Source lines of code, SLOC, Source statements, Source code size, Software planning and tracking.

Abstract: In telecommunications switching systems, software is frequently modified, enhanced or replaced altogether by new versions. The implementation or integration of the new or revised software into the operational system must be accomplished in accordance with strict requirements for not disturbing the ongoing activities of the system. Therefore, it is desirable that the system not be halted while the change to the new software is made. Rather, the preferred approach is to be able to replace software modules with new versions on the fly, during system operation. The smooth modification made possible in the disclosed system allows such changes with minimal disturbance to ongoing activities by dynamically linking and binding software modules during execution. The disclosed system accomplishes this by applying expanded object-oriented programming techniques and utilizing language-independent interface specifications that remain unchanged and that obviate the need for storing symbolic information that would be subject to change following modification.

Abstract: From the Publisher: The development of high-quality software is an issue of great and growing importance throughout the software industry. This book introduces software quality in a clear, accessible manner, bridging the gap between software engineering and software management. Software Quality is written in two principle parts. The first part describes the concept of quality and the way in which it can be applied to software, with descriptions of the techniques employed in software quality assurance. The second part shows how these techniques can be used and discusses the standards involved. It also includes a case study of a company's experience in the development of quality issues, from product failure through to the introduction of structured systems, design methods and consideration of standards accreditation. A final section looks forward to the future of the subject. This book is unique in dealing with both the theory of quality management and its application in software development. The latest information on standards has been included. All those professionally involved with developing high-quality software will find this book invaluable.

Abstract: Object-oriented programming techniques promote a new approach to software engineering in which reliable, open applications can be lar gely constructed, rather than programmed, by reusing “frameworks” [3] of plug-compatible software components. Although the dream of a components-based software industry is very old [9], only now does it appear that we are close to realizing the dream. The reason for this is twofold: • Modern applications are increasingly open in terms of topology, platform and evolution, and so the need for a component-oriented approach to development is even more acute than in the past; • Objects provide an organizational paradigm for decomposing large applications into cooperating objects as well as a reuse paradigm for composing applications from pre-packaged software components. Despite the contributions of object-oriented technology , there are several open research problems that must be resolved to reach the goal of ef f ctive component-oriented development. First, object-oriented mechanisms for composition and reuse must be cleanly integrated with other features, such as concurrency , persistence and distribution. Second, ef fective reuse of software presupposes the existence of tools to support the organisation and retrieval of components according to application requirements and the interactive construction of running applications from components. Third, the design of reusable frameworks is an iterative, evolutionary process, so it is necessary to manage software and software information in such a way that designs and implementations can evolve gracefully. Finally, present object-oriented methodologies do not explicitly address the design of reusable frameworks. Not only the languages and tools, but the economics, methods and culture of software development must ultimately adapt to a new evolutionary software life-cycle if we are to realize the benefits of large-scale software reuse [2][17].

Abstract: 1. Introduction 2. A Simple Z Specification 3. Sets and Predicates 4. Relations and Functions 5. Schemas and Specifications 6. Data Design 7. Algorithm Design

Abstract: Understanding object-oriented technology. Motivation for an object-oriented approach to software engineering. What are methodologies? Life-cycle approaches. Understanding the recursive/parallel life-cycle. Abstraction, encapsulation and information hiding. Object cohesion. Object and class specifications. Large object-oriented entitles. Object-oriented requirements analysis. Object-oriented design. Evaluating an object-oriented programming language. Issues in testing object-oriented software. Specifying test cases for object-oriented software. Readings in object-oriented technology. Appendix: sample object and class specifications.

Abstract: The software engineering a holistic view that we provide for you will be ultimate to give preference. This reading book is your chosen book to accompany you when in your free time, in your lonely. This kind of book can help you to heal the lonely and get or add the inspirations to be more inoperative. Yeah, book as the widow of the world can be very inspiring manners. As here, this book is also created by an inspiring author that can make influences of you to do more.

Abstract: : This report presents mechanisms for describing and specifying two software measures-software problems and defects-used to understand and predict software product quality and software process efficacy. We propose a framework that integrates and gives structure to the discovery, reporting, and measurement of software problems and defects found by the primary problem and defect finding activities. Based on the framework, we identify and organized measurable attributes common to these activities. We show how to use the attributes with checklists and supporting forms to communicate the definitions and specifications for problem and defect measurements. We illustrate how the checklist and supporting forms can be used to reduce the misunderstandings of measurement results and can be applied to address the information needs of different users.

Abstract: The relationship between software testing and reliability is discussed. Two kinds of reliability models, reliability-growth models, which are applied during debugging, and reliability models, which are applied after debugging, are described. Several reasons for the failure of conventional reliability theory in software engineering are presented. It is argued that until random testing of a million points becomes practical, testing for quality is only a poor competitor for other heuristic defect-detection methods. >

Abstract: The subject of this paper is the description of a process-centered software development environment called MERLIN which monitors and guides teams of software developers and managers in producing software objects. Software objects (or objects for short) include all sorts of documents like requirements analysis, design, code, user manuals, contracts etc. For each user, MERLIN automatically displays a specific working context which contains information like objects, their relations, their current development state, and corresponding tools. This information is filtered according to the (access) rights and duties a particular user has in a particular project, i.e. the working context depends on the user's role (e.g. programmer, designer, manager). Internally, the computation of the information to be contained in a working context, is based on a rulelike definition of a software process and a flexible interpretation mechanism to enact such a process definition. The main feature of the interpreter is an alternating use of backward and forward chaining for the interpretation of rules. In addition, our implementation enables a persistent storage and incremental update during runtime of all process information expressed in facts within the MERLIN knowledge base.

Abstract: Quality Planning--Doing the Right Things. The Management and Planning Tools. The Software Quality Problem-Solving Process. Plan--Investigate the Problem. Do--Identify and Implement Proposed Solutions. Check Results. Act to Integrate and Sustain Solutions. Quality Improvement Teams. Process Management--Doing Things Right. Supporting Software Quality Improvement. Quality in Software Evolution. Rapid Evolutionary Development. Software Evolution. A QI Story. Bibliography. Appendices. Index.

Abstract: Software visualization is the use of interactive computer graphics, typography, graphic design, animation, and cinematography to enhance the interface between the software engineer or the computer science student and their programs. Although several taxonomies of software visualization have been proposed, they use few dimensions and do not span the space of important distinctions between systems. The authors propose a novel and systematic taxonomy of six areas making up thirty characteristic features of software visualization technology. The taxonomy is presented and illustrated in terms of its application to seven systems of historic importance and technical interest. >

Abstract: Reverse engineering is the process of extracting system abstractions and design information out of existing software systems. This information can then be used for subsequent development, maintenance, re-engineering, or reuse purposes. This process involves the identification of software artifacts in a particular subject system, and the aggregation of these artifacts to form more abstract system representations. This paper describes a reverse engineering environment which uses the spatial and visual information inherent in graphical representations of software systems to form the basis of a software interconnection model. This information is displayed and manipulated by the reverse engineer using an interactive graph editor to build subsystem structures out of software building blocks. The spatial component constitutes information about how a software structure looks. The coexistence of these two representations is critical to the comprehensive appreciation of the generated data, and greatly benefits subsequent analysis, processing, and decision-making.

Abstract: This book discusses software reusability and how it can increase programmer productivity; re-engineering or how software automation can be used to address software maintenance problems; and repositories, the foundation for an integrated CASE environment. It provides software tools product examples and real-world examples of how corporations use this technology to leverage their huge investments in software systems and tools to the fullest extent.

Abstract: Recently, a considerable number of object-oriented software development methods have been introduced to produce extensible, reusable, and robust software. We have been involved in the development of a large number of pilot applications to form our own view on object-oriented methods. Although our experiences confirmed the claims about the benefits of object-oriented methods, we identified a number of important obstacles that are not addressed by current methods. This paper summarizes these obstacles and evaluates them with respect to our pilot applications. The aim of this paper is to make software engineers aware of problems they may encounter during object-oriented development, and to inspire researchers to initiate new research activities.

Abstract: Provides an overview of a step-by-step approach for developing the operational profile used in software reliability engineering. The operational profile can help guide managerial and engineering decisions throughout the product life cycle, including requirements specification, design, implementation and testing. It is particularly valuable in guiding test planning and testing. The development and use of this profile typically involves product and market managers and systems engineers. It is used by software developers and managers, system test planners and testers, and quality assurance and reliability engineers. The presented material has been drawn from experience in developing operational profiles for a variety of applications. >

Abstract: An acceptable measure of software quality must quantify software complexity. Traditional software metrics such as lines of code, software science and cyclomatic complexity are investigated as possible indicators of complexity of object-oriented systems. This research reports the effects of polymorphism and inheritance on the complexity of object-oriented systems are measured by the traditional metrics. The results of this research indicate that traditional metrics are applicable to the measurement of the complexity of object-oriented systems. >

Abstract: The author presents a conceptual foundation for software re-engineering. The foundation is composed of properties and principles that underlie re-engineering methods, and assumptions about re-engineering. The value of this conceptual foundation is its ability to model understanding of re-engineering, how it is practiced, and how it can be practiced. A general model of software re-engineering is established, based on this foundation. This model, along with its underlying foundation, proves useful for examining issues such as the re-engineering process and strategies. >

Abstract: One of the major problems in cooperative software development is that of maintaining certain global consistency properties. Broadcasting changes that have already occured, as many programming environments do, will not resolve this problem. We argue in favor of an architecture where the announcements deal with impending or proposed changes as well as changes that have already occurred. One can then formulate consistency requirements on the system that are maintained “lazily” as it evolves. Such an architecture can support a wider range of cooperative processes than traditional software development environments. This paper describes the design and implementation of this architect ure.

Abstract: : This document describes a set of software measures that are compatible with the measurement practices described in the Capability Maturity Model for Software. These measures, in the form of software indicators, cover thirteen different categories that include progress, effort, cost, and quality. Each indicator category contains example figures which illustrate behavior that may occur on a project. The text provides users with tips on how to use these figures or similar ones on their projects. Project software managers and software engineering process groups can use these indicators during the software development life cycle to gain insight into the software development process and software process improvement activities. The indicators chosen have been successfully used on projects in the software industry.

Abstract: Accurately predicting the number of faults in program modules is a major problem in the quality control of a large scale software system. In this paper, the use of the neural networks as a tool for predicting the number of faults in programs is explored. Software complexity metrics have been shown to be closely related to the distribution of faults in program modules. The objective in the construction of models of software quality is to use measures that may be obtained relatively early in the software development life cycle to provide reasonable initial estimates of quality of an evolving software system. Measures of software quality and software complexity to be used in this modeling process exhibit systematic departures of normality assumptions of regression modeling. This paper introduces a new approach for static reliability modeling and compares its performance in the modeling of software reliability from software complexity in terms of the predictive quality and the quality of fit with more traditional regression modeling techniques. The neural networks did produce models with better quality of fit and predictive quality when applied to one data set obtained from a large commercial system. >

Abstract: Measurement of software development productivity is needed in order to control software costs, but it isdiscouragingly labor-intensive and expensive. Computer aided software engineering (CASE) technologies --especially repository-based, integrated CASE -- have the potential to support the automation of thismeasurement. In this paper, we discuss the development of automated analyzers for function point andsoftware reuse measurement for object-based CASE. Both analyzers take advantage of the existence of arepresentation of the application system that is stored within an object repository, and that contains thenecessary information about the application system. We also discuss metrics for software reusemeasurement, including reuse leverage, reuse value and reuse classification, that are motivated by managerialrequirements and the efforts, within industry and the IEEE, to standardize measurement. The functionalityand the analytical capabilities of state-of-the-art automated software metrics analyzers are illustrated in thecontext of an investment banking industry application, that is similar to systems deployed at the New YorkCity-based investment bank where these tools were developed and tested.