Abstract: Continuous availability is a critical requirement for an important class of software systems. For these systems, runtime system evolution can mitigate the costs and risks associated with shutting down and restarting the system for an update. We present an architecture-based approach to runtime software evolution and highlight the role of software connectors in supporting runtime change. An initial implementation of a tool suite for supporting the runtime modification of software architectures, called ArchStudio, is presented.

Abstract: Experimentation helps determine the effectiveness of proposed theories and methods. However, computer science has not developed a concise taxonomy of methods for demonstrating the validity of new techniques. Experimentation is a crucial part of attribute evaluation and can help determine whether methods used in accordance with some theory during product development will result in software being as effective as necessary. By looking at multiple examples of technology validation, the authors develop a taxonomy for software engineering experimentation that describes twelve different experimental approaches.

Abstract: A software package manager uses a distribution unit containing components for a software package and a manifest file that describes the distribution unit to manage the installation, execution, and uninstallation of software packages on a computer. Information in the manifest file pertaining to a software package is stored in a code store data structure upon installation of the package. The manifest file also contains information that permits the software package manager to resolve any software dependencies upon installation. The software package manager uses the code store data structure to locate the required components when the software is executed and to remove the components appropriately when the software is uninstalled.

Abstract: From the Publisher: A firm grounding in software engineering theory and practice is essential for understanding how to build good software and for evaluating the risks and opportunities that software presents in our lives. Software Engineering blends the two current software engineering worlds: that of the practitioner whose main focus is on building high-quality products to perform useful functions, and that of the researcher who strives to improve the quality of products and the productivity of those who build them. Dr. Pfleeger presents concepts at both the micro and macro levels, using numerous case studies and examples to illustrate clearly how large software development projects progress from need to idea to reality.

Abstract: Aspects of software Measurement history of Software Measurement foundation of Software Measurement I foundations of Software Measurement II Measurement theory and object-oriented software measures desirable properties of software measures validation of software measures and prediction models applications of software measures afterword solutions of exercises glossary of terms and terms used as synonyms. Attachment 1 - the system ZD-MIS attachment 2 - proof of the equivalence of extensive structures attachment 3 - proof of the theorems of chapter 8 attachment 4 - proof of the theorems of chapter 5 attachment 5 - notations and used symbols attachment 6 - axioms systems definitions theorems exercises references to literature name and subject indexes.

Abstract: This book will help you to manage and control the quality of your organization's software products Continually dealing with the problems caused by software defects can be both time-consuming and demanding but Sami Zahran's pragmatic approach will take you from reactive fire-fighting to a preventative culture of disciplined and continuous process improvement This book will help you: establish a process-focused software development organizatio design and implement procedures for developing quality software in time and within budge benchmark your organization against the industry standards for the software process, including the Capability Maturity Model (CMM), ISO 9001, the new standard ISO/IEC 15504 (originally known as SPICE) and Bootstrap

Abstract: Components designed for reuse are expected to lower costs and shorten the development life cycle, but this may not prove so simple. The author emphasizes the need to closely examine a problematic aspect of component reuse: the necessity and potential expense of validating components in their new environments.

Abstract: Software maintenance claims a large proportion of organizational resources. It is thought that many maintenance problems derive from inadequate software design and development practices. Poor design choices can result in complex software that is costly to support and difficult to change. However, it is difficult to assess the actual maintenance performance effects of software development practices because their impact is realized over the software life cycle. To estimate the impact of development activities in a more practical time frame, this research develops a two-stage model in which software complexity is a key intermediate variable that links design and development decisions to their downstream effects on software maintenance. The research analyzes data collected from a national mass merchandising retailer on 29 software enhancement projects and 23 software applications in a large IBM COBOL environment. Results indicate that the use of a code generator in development is associated with increased software complexity and software enhancement project effort. The use of packaged software is associated with decreased software complexity and software enhancement effort. These results suggest an important link between software development practices and maintenance performance.

Abstract: Commercial off the shelf software can save development time and money if you can find a package that meets your customer's needs. The authors propose a model for matching COTS product features with user requirements. To support requirements acquisition for selecting commercial off the shelf products, we propose a method we used recently for selecting a complex COTS software system that had to comply with over 130 customer requirements. The lessons we learned from that experience refined our design of PORE (procurement oriented requirements engineering), a template based method for requirements acquisition. We report 11 of these lessons, with particular focus on the typical problems that arose and solutions to avoid them in the future. These solutions, we believe, extend state of the art requirements acquisition techniques to the component based software engineering process.

Abstract: A system of computer manufacturing with pre-installation of software which utilizes a software selection process controlled by a rules database to determine the proper software components to be pre-installed onto an assembled computer or hard drive. Additionally, the rules base determines the appropriate diagnostic and set-up software components to be installed in order to ensure a system that is ready-to-run upon receipt by a purchaser.

Abstract: Applications are often designed to take advantage of the potential for integration with each other via shared information. Current approaches for integration are limited, affecting both the programmer and end-user. In this paper, we present CyberDesk, a framework for self-integrating software in which integration is driven by user context. It relieves the burden on programmers by removing the necessity to predict how software should be integrated. It also relieves the burden from users by removing the need to understand how to make different software components work together.

Abstract: One of the major costs in a software project is the construction of test-data. This paper outlines a generalised test-case data generation framework based on optimisation techniques. The framework can incorporate a number of testing criteria, for both functional and non-functional properties. Application of the optimisation framework to testing specification failures and exception conditions is illustrated. The results of a number of small case studies are presented and show the efficiency and effectiveness of this dynamic optimisation-base approach to generating test-data.

Abstract: Goals The goals of this course are to teach universal procedural programming skills, to teach problem decomposition algorithm development, and debugging, to teach numerical methods and their practical implementation for engineering problems, and to demonstrate the practical application of computers as an engineering tool. The material will be presented assuming the student has no prior programming experience. The primary vehicle for teaching programming skills will be the Matlab programming environment, however the skills learned will be readily adaptable to other languages that the student may work with in future. In addition, the use of the MathCad mathematical worksheet software will be covered. The first segment of the course will cover programming in Matlab and MathCad while the second segment will cover numerical methods and their implementation using Matlab and MathCad.

Abstract: A method and mechanism for automatically installing software implementations such as applications and COM classes as they are needed from an external source. When a software implementation is needed, the mechanism first looks to the local system (e.g., registry) for that software implementation, and if found, returns the information such as a local path needed to use the software implementation. If the implementation is not found, the mechanism looks to another source, such as a CD-ROM or a centralized class store of a network, to locate the needed implementation. When located, the implementation is downloaded and locally installed from the source, and a local path is returned in a manner that is essentially transparent to the user. Software implementations such as application products may be divided into features and components to improve on-demand installation thereof.

Abstract: The study of storage and retrieval methods of software assets in software libraries gives rise to a number of paradoxes: While this subject has been under investigation for nearly two decades, it still remains an active area of research in software reuse and software engineerings this can be explained by the observation that new technologies (such as the internet, the world wide web, objectdoriented programming) keep opening new opportunities for better asset packaging, better library organizations, and larger scale libraries – thereby posing new technical challenges. Also, while many sophisticated solutions have been proposed to this problem, the state of the practice in software reuse is characterized by the use of addhoc, lowdtech methodss this can be explained by the observation that most existing solutions are either too ineffective to be useful or too intractable to be usable. Finally, while it is difficult to imagine a successful software reuse program without a sophisticated, welldtuned, systematic procedure for software component storage and retrieval, it seems many successful software reuse experiments rely on trivial methods of component storage and retrievals this can be explained by the observation that, in the current state of the practice, software libraries are not the bottleneck of the software reuse process. This paper presents a survey of methods of storage and retrieval of software assets in software libraries. In addition to a review of existing research efforts, the paper makes two contributions. First, a definition of (presumably) orthogonal attributes of storage and retrieval methodss these attributes are used, in turn, to classify existing methods into six broad classes. Second, a definition of (presumably) orthogonal assessment criteria, which include technical, managerial and human factorss these criteria afford us an exhaustive and uniform basis for assessing and comparing individual methods and classes of methods.

Abstract: Ever increasing embedded system design complexity combined with a very tight time-to-market window has revolutionized the embedded-system design process. The concurrent design of hardware and software has displaced traditional sequential design. Further, hardware and software design now begins before the system architecture (or even the specification) is finalised. System architects, customers, and marketing departments develop requirement definitions and system specifications together. System architects define a system architecture consisting of cooperating system functions that form the basis of concurrent hardware and software design. Interface design requires the participation of both hardware and software developers. The next step integrates and tests hardware and software-this phase consists of many individual steps. Reusing components taken from previous designs or acquired from outside the design group is a main design goal to improve productivity and reduce design risk. It is argued that new methodologies and AD tools support an integrated hardware software codesign process.

Abstract: Developers need tool support to help manage the wide range of inconsistencies that occur during software development. Such tools need to provide developers with ways to define, detect, record, present, interact with, monitor and resolve complex inconsistencies between different views of software artifacts, different developers and different phases of software development. This paper describes our experience with building complex multiple-view software development tools that support diverse inconsistency management facilities. We describe software architectures that we have developed and user interface techniques that are used in our multiple-view development tools, and we discuss the effectiveness of our approaches compared to other architectural and HCI techniques.

Abstract: An anti-piracy system reduces the opportunity for piracy and illicit use of software products by requiring each software product to be registered for a single computer. If a user attempts to install the software product on another computer, the software product will recognize a different hardware composition and disable itself. During installation, the software product generates a hardware ID that identifies the set of hardware components and sends it and a product ID to a registration authority. The registration authority computes a registration ID from the product ID and the hardware ID and sends the registration ID back to the software product. Each time the software product is subsequently launched, the software product computes its own test ID from the product ID and hardware ID using the same algorithm employed by the registration authority. The software product then compares the test ID to the registration ID. If the two match, the software product is enabled; otherwise, if no match occurs, the software product is locked. The system flexibly accommodates a situation in which the user upgrades one or a few components in the computer without creating a new machine. The software product determines whether a new set of hardware components in the computer is substantially different from the original set of hardware components. If not substantially different, the upgraded computer is more like the original computer and the software product is permitted to operate; otherwise, the computer more resembles a new computer and the software product is prevented from operating.

Abstract: Dynamic information collected as a software system executes can help software engineers perform some tasks on a system more effectively. To interpret the sizable amount of data generated from a system's execution, engineers require tool support. We have developed an off-line, flexible approach for visualizing the operation of an object-oriented system at the architectural level. This approach complements and extends existing profiling and visualization approaches available to engineers attempting to utilize dynamic information. In this paper, we describe the technique and discuss preliminary qualitative studies into its usefulness and usability. These studies were undertaken in the context of performance tuning tasks.

Abstract: Applications are often designed to take advantage of the potential for integration with each other via shared information. Current approaches for integration are limited, affecting both the programmer and end-user. In this paper, we present CyberDesk, a framework for self-integrating software in which integration is driven by user context. It relieves the burden on programmers by removing the necessity to predict how software should be integrated. It also relieves the burden from users by removing the need to understand how to make different software components work together. q 1998 Elsevier Science B.V. All rights reserved.

Abstract: An essential characteristic of large scale software development is parallel development by teams of developers. How this parallel development is structured and supported has a profound effect on both the quality and timeliness of the product. We conduct an observational case study in which me collect and analyze the change and configuration management history of a legacy system to delineate the boundaries of, and to understand the nature of, the problems encountered in parallel development. The results of our studies are: 1) that the degree of parallelism is very high-higher than considered by tool builders; 2) there are multiple levels of parallelism and the data for some important aspects are uniform and consistent for all levels and 3) the tails of the distributions are long, indicating the tail, rather than the mean, must receive serious attention in providing solutions for these problems.

Abstract: A system for changing a software library during the execution of a software application using the software library. The software application interfaces to the software library only through the use of an interface library, to ensure that the software application does not directly bind with the software library. With no direct binding the software library can be updated during runtime without the software application re-resolving the location of the software library. The update is triggered by a change of the version number in a registry. The program correctness is maintained by library management services ensuring that the software library is no longer in use by the application before updating to the new library. Memory management services are used to ensure that the state of the library is maintained between the old and the updated versions of the software library.

Abstract: Defect causal analysis offers a simple, low-cost method for systematically improving the quality of software produced by a team, project, or organization. DCA takes advantage of one of the most widely available types of quality information, the software problem report. This information drives a team-based technique for defect causal analysis. The analysis leads to process changes that help prevent defects and ensure their early detection. The paper discusses the three principles that drive the DCA approach. It considers the impact of DCA on an organization.

Abstract: An approach to recover object oriented design patterns from design and code is presented. The pattern recovery process is based on a multi-stage filtering strategy to avoid combinatorial explosion on large software systems. To maintain independence from the language and the case tools adopted in developing software, both design and code are mapped into an intermediate representation. The multi-stage searching strategy allows to safely determine pattern candidates. To assess the effectiveness of the pattern recovery process a portable environment written in Java has been developed. Based on this environment, experimental results on public domain and industrial software were obtained and are discussed in the paper. Evidence is shown that, by exploiting information about method calls as a further constraint beyond the structural ones, the number of false positives is reduced.

Abstract: Empirical evaluation of software systems in actual usage situations is critical in software engineering Prototyping, beta testing, and usability testing are widely used to refine system requirements, detect anomalous or unexpected system and user behavior, and to evaluate software usefulness and usability The World Wide Web enables cheap, rapid, and large-scale distribution of software for evaluation purposes However, current techniques for collecting usage data have not kept pace with the opportunities presented by Web-based deployment This paper presents an approach and prototype system that makes large-scale collection of usage data over the Internet a practical possibility A general framework for comparing software monitoring systems is presented and used to compare the proposed approach to existing techniques

Abstract: Software for safety critical systems must deal with the hazards identified by safety analysis. This paper investigates, how the results of one safety analysis technique, fault trees, are interpreted as software safety requirements to be used in the program design process. We propose that fault tree analysis and program development use the same system model. This model is formalized in a real-time, interval logic, based on a conventional dynamic systems model with state evolving over time. Fault trees are interpreted as temporal formulas, and it is shown how such formulas can be used for deriving safety requirements for software components.

Abstract: Techniques for providing extensible applications arc provided. A bundle or software module can be developed that is able to install itself within an application. The software module can also inform the application upon which services the software module depends so that if the required services are not available, the application can obtain them. An activation function can be defined in the software module that registers the services provided by the software module with the application so that the services can be available to other software modules.

Abstract: Widespread use of embedded systems is occurring due to the increase in complexity of digital devices and systems. These systems are currently being implemented by software and hardware components in order to benefit from the strengths of each technology. We present an introduction to hardware/software codesign techniques for embedded systems.