Abstract: A method for upgrading ( 31 - b of FIG. 1 ) a software application ( 35 - b ) from a prior version to a subsequent version while preserving user modifications to the prior application. The method includes comparing differences between the two versions of the software applications. This is followed by enumerating the differences between the two versions of the software applications; and determining which differences between the two versions of the software are conflicting and which are compatible. The compatible changes are made ( 7 ). Also disclosed is an article of manufacture containing computer readable program code for carrying out the above process, and a program storage device carrying the code.

Abstract: From the Publisher: Encompasses the field of software development process--from design to transpiration to testing and everything in between. Includes all functional disciplines, software tools and languages associated with software engineering of large and/or complex projects. Organized alphabetically--every major area contains an overview article that defines the topic. Each sub-discipline has a specific article covering history, current practice, practical data and projections about future practice.

Abstract: We present the detailed planning and execution of the Insight Toolkit (ITK), an application programmers interface (API) for the segmentation and registration of medical image data. This public resource has been developed through the NLM Visible Human Project, and is in beta test as an open-source software offering under cost-free licensing. The toolkit concentrates on 3D medical data segmentation and registration algorithms, multimodal and multiresolution capabilities, and portable platform independent support for Windows, Linux/Unix systems. This toolkit was built using current practices in software engineering. Specifically, we embraced the concept of generic programming during the development of these tools, working extensively with C++ templates and the freedom and flexibility they allow. Software development tools for distributed consortium-based code development have been created and are also publicly available. We discuss our assumptions, design decisions, and some lessons learned.

Abstract: Software-based approaches enable engineers to build wireless system radios that are easier to manufacture, more flexible, and more cost-effective. Software Radio: A Modern Approach to Radio Engineering systematically reviews the techniques, challenges, and tradeoffs of DSP software radio design. Coverage includes constructing RF front-ends; using digital processing to overcome RF design problems; direct digital synthesis of modulated waveforms; A/D and D/A conversions; smart antennas; object-oriented software design; and choosing among DSP microprocessors, FPGAs, and ASICs. This is an excellent book for all RF and signal processing engineers building advanced wireless systems.

Abstract: Computer-Aided Chemical Engineering is reviewed from its beginnings in the 1950s to the present state in which virtually all chemical engineering is computer-aided. Over 200 computer-based computations routinely undertaken by chemical engineers are listed. Computer-aids are used at every stage from deciding what chemical species to make, through the conceptual design of the processes, the detailed design, the on-line control, optimization and retrofit design, up to the decommissioning. Computer-aids are important for assessing and minimizing environmental impacts and hazards. This chapter does not discuss any of these topics in detail. It concentrates on the design of reliable software and the correct use of software supplied by third parties. Guidance is given for designing software that properly meets the technical requirements of the end users. The program structure and test procedures necessary to validate the software are described. Methods for ensuring that the program properly incorporates the physical models on which it is based are outlined including emphasis on dimensionally consistent programming. The importance of data validation is emphasized. It is further emphasized that these design guidelines apply equally to models written in special-purpose modeling systems as they do to models written in general-purpose computer-programming languages. The elements of numerical analysis are introduced and illustrated with common examples from chemical engineering. Even simple computations, such as log–mean temperature difference, can be grossly in error if the numerical limitations of computers are ignored. Reliable, easily solved models should be near-linear and explicit, and steps to achieve such models are included. The treatment is designed to be adequate for engineers writing small programs, or small parts of larger programs. References are introduced to enable professional engineering programmers to pursue the topics in greater depth. End-users of chemical engineering software have responsibility for the decisions taken based on computed results. They must ensure that the software is adequate for its purpose, that all data is properly validated, and that the computed results are properly interpreted. They are also responsible for scoping the uncertainties in the computation and assessing their impact on the decisions taken. This chapter describes the steps that should be taken to ensure that computer aids are properly used and decisions are properly reached. It gives further reading for engineers likely to manage projects in which extensive use is made of computer tools. A brief introduction is given to some of the rapidly advancing areas of computer-aided chemical engineering. Keywords: CAPE (Computer-Aided Process Enginerring); program design; software validation; Numerical Analysis; Software use; CAMD (Computer-Aided Molecule Design); process synthesis; flexible process design

Abstract: Web applications have very high requirements for numerous quality attributes. This article discusses some of the technological challenges of building today's complex Web software applications, their unique quality requirements, and how to achieve them.

Abstract: Tropos is a novel agent-oriented software development methodology founded on two key features: (i) the notions of agent, goal, plan and other knowledge level concepts are used uniformly throughout the software development process; and (ii) a crucial role is assigned to requirements analysis and specification when the system-to-be is analyzed with respect to its intended environment. This short paper outlines basic elements of the Tropos methodology: the conceptual framework and the analysis process through which design flows from external to system actors through a goal analysis and delegation.

Abstract: This paper describes the scaling issues and progress towards constructing a practical program transformation system to support software evolution.

Abstract: Software product lines are emerging as a viable, important software development paradigm. Based on the Software Engineering Institute's research and experience, the concepts, activities, and practices described here can lead to successful product line development. How-to's, success stories, and lessons learned expand on the approach.

Abstract: An important goal of most empirical software engineering research is the transfer of research results to industrial applications. Two important obstacles for this transfer are the lack of control of variables of case studies, i.e., the lack of explanatory power, and the lack of realism of controlled experiments. While it may be difficult to increase the explanatory power of case studies, there is a large potential for increasing the realism of controlled software engineering experiments. To convince industry about the validity and applicability of the experimental results, the tasks, subjects and the environments of the experiments should be as realistic as practically possible. Such experiments are, however, more expensive than experiments involving students, small tasks and pen-and-paper environments. Consequently, a change towards more realistic experiments requires a change in the amount of resources spent on software engineering experiments. This paper argues that software engineering researchers should apply for resources enabling expensive and realistic software engineering experiments similar to how other researchers apply for resources for expensive software and hardware that are necessary for their research. The paper describes experiences from recent experiments that varied in size from involving one software professional for 5 days to 130 software professionals, from 9 consultancy companies, for one day each.

Abstract: A method and system for installing software implementations such as applications and COM classes as they are needed from an external source, such as a centralized network store. When a software implementation is needed, the system and method first look 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 locally, the present invention dynamically looks to a centralized class store of a network, to locate the needed implementation. When located, the implementation is downloaded and locally installed 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: Software systems come and go through a series of passages that account for their inception, initial development, productive operation, upkeep, and retirement from one generation to another. This article categorizes and examines a number of methods for describing or modeling how software systems are developed. It begins with background and definitions of traditional software life-cycle models that dominate most textbook discussions and current software development practices. This is followed by a more comprehensive review of the alternative models of software evolution that are of current use as the basis for organizing software engineering projects and technologies. Keywords: software process model; definition; software life-cycle models; development models; production process models

Abstract: Software product lines have received considerable adoption in the software industry and prove to be a very successful approach to intra-organizational software reuse Existing literature, however, often presents only a single approach towards adopting and evolving a software product line In this paper, we present an overview of different approaches to the architecture-centric, intra-organizational reuse of software artefacts We relate these to maturity levels for product line artefacts and organizational models

Abstract: 1. Software and Software Engineering. 2. Review of Object Orientation and Java. 3. Basing Software Development on Reusable Technology. 4. Developing Requirements. 5. Modelling with Classes. 6. Using Design Patterns. 7. Focusing on Users and Their Tasks. 8. Modelling Interactions and Behaviour. 9. Architecting and Designing Software. 10. Testing and Inspecting to Ensure High Quality. 11. Managing the Software Process. 12. Review. Appendix A: Summary of UML Notation used in this Book. Appendix B: Summary of the Documentation Formats Recommended in this Book. Appendix C: System Descriptions. Appendix D: Answers to Selected Exercises. Glossary. Index.

Abstract: A method for analyzing impact on binaries, software, and hardware of a planned software upgrade for a computer system. The method includes performing a configuration inventory for the computer system with profiles for the computer system of hardware, software including operating system software, middleware, applications, development tools, and third party software, application interfaces, and binaries. A set of upgrade rules, e.g., rules defining hardware and software requirements including interfaces, libraries, dependencies, and more, are accessed and the binary profiles are analyzed based on the upgrade rules to determine safe binaries and at-risk binaries. The at-risk binaries are further divided into subcategories based on risks of incompatibility with the planned software upgrade. The subcategories include failure, high risk, and low risk. The method includes generating text or graphical reports providing the analysis results to quantify and qualify the impacts on binaries and other portions of the computer system.

Abstract: A method and system for an embedded software update system, which helps manufactures or vendors avoid costly product recall activities in the event their digital products have field software errors ('bugs') or hardware problems. One aspect of the invention is directed to an error correction system, which remotely corrects these software errors and minimizes influences of hardware problems. Another aspect of the invention is to a software updating system, which is capable of updating software modules in the digital products by use of software patches. The software patch system of the present invention facilitates manufactures' transmitting software patches to the 'on-the-fly' digital products to fix software errors and minimize influences of hardware problems. The software patch may also contain new parameters for updating some data area in NVM (Non Volatile Memory), EEPROM (Electrically Erasable Programmable Read-Only Memory) memory of a digital product, which is quite useful when service providers or manufactures want to modify some service features or product features.

Abstract: OSDI '02 continues the conference's tradition of presenting the best innovative work in the systems software area, taking a broad view of what the area encompasses. We believe that this year's conference contains some of the most original, intriguing, and important work in the field today. OSDI '02 drew a highly competitive selection from a large collection of diverse, original work submitted by authors internationally to form a program of creative, well-developed papers opening up new and innovative areas--not merely incremental results building on prior work.The program presents important results in a wide range of areas, including distributed storage systems, robust software construction, OS kernel innovations, sensor networks, virtual machine monitors, large-scale network simulation, resource management architectures for Internet services, peer-to-peer systems, network analysis, and migration of execution environments.OSDI '02 received 150 submissions; all submissions were reviewed by several members of the program committee and selected external reviewers, comprising roughly 700 reviews. Program committee members did not participate in the review or discussion of any papers co-authored by themselves, members of their home institutions, former students, advisors, or recent collaborators. The program committee met at the Intel Berkeley research lab on July 30, 2002, to make the final program selection during an eleven-hour meeting.

Abstract: Two dichotomies characterize software process improvement efforts and approaches: disciplined versus creative work and procurer risks versus user satisfaction. Based on these perspectives, the authors introduce six theses to illuminate the problems of pursuing SPI.

Abstract: For large, complex ICs, engineers need efficient techniques for debugging first silicon. The system presented here consists of an on-chip debug infrastructure and supporting debugger software,which interacts with the infrastructure to make the chip's features accessible through a serial interface.

Abstract: Die Online-Fachbuchhandlung beck-shop.de ist spezialisiert auf Fachbücher, insbesondere Recht, Steuern und Wirtschaft. Im Sortiment finden Sie alle Medien (Bücher, Zeitschriften, CDs, eBooks, etc.) aller Verlage. Ergänzt wird das Programm durch Services wie Neuerscheinungsdienst oder Zusammenstellungen von Büchern zu Sonderpreisen. Der Shop führt mehr als 8 Millionen Produkte.

Abstract: A method and apparatus for synchronizing software between computers are disclosed. A software fix manager compares a preferred software inventory with a software inventory from a computer that is to be synchronized and, from this comparison, creates a number of software product synchronizations. An update manager uses the software fix list to apply software product synchronizations to the computer. Preferably, the computer can be brought to the same fix level or product level, if desired, as the preferred software inventory through this process. The software fix manager can place synchronizations in a fix list. There can be multiple software product synchronizations per software product, and the synchronizations can be applied to a computer by removing a software product fix or installing a product software fix. The current invention may also be applied to software products themselves, by installing or removing software products. The present invention potentially has its best application in networks, as numerous target computers or groups of target computers may be synchronized with a preferred software inventory of a model system.

Abstract: During maintenance, systems are updated to correct faults, improve functionality, and adapt the software to changes in its execution environment. The typical software update process consists of stopping the system to be updated, performing the update of the code, and restarting the system. For systems such as banking and telecommunication software, however the cost of downtime can be prohibitive. The situation is even worse for systems such as air-traffic controllers and life-support software, for which a shut-down is in general not an option. In those cases, the use of some form of on-the-fly program modification is required. In this paper, we present a new technique for dynamic updating of Java software. Our technique is based oil the use of proxy classes and requires no support from the runtime system. The technique allows for updating a running Java program by substituting, adding, and deleting classes. We also present DUSC (dynamic updating through swapping of classes), a tool that we developed and that implements our technique. Finally, we describe an empirical study that we performed to validate the technique of a real Java subject. The results of the study show that our technique can be effectively applied to Java software with only little overhead in both execution time and program size.

Abstract: Lessons. Foreword. Preface. Acknowledgments. The Role of the Tester. Thinking Like a Tester. Testing Techniques. Bug Advocacy. Automating Testing. Documenting Testing. Interacting with Programmers. Managing the Testing Project. Managing the Testing Group. Your Career in Software Testing. Planning the Testing Strategy. Appendix: The Context-Driven Approach to Software Testing. Bibliography. Index.

Abstract: As Component-based Software Development (CBSD) starts to be effectively used, some software vendors have commenced to successfully sell and license commercial off-the-shelf (COTS) components. One of the most critical processes in CBSD is the selection of the COTS components that meet the user requirements. Current proposals have shown how to deal with the functional aspects of this evaluation process. However, there is a lack of appropriate quality models that allow an effective assessment of COTS components. Besides, the international standards that address the software products' quality issues (in particular, those from ISO and IEEE) have shown to be too general for dealing with the specific characteristics of software components. In this position paper we propose a quality model for CBSD based on ISO 9126, that defines a set of quality attributes and their associated metrics for the effective evaluation of COTS components.

Abstract: The derivation of system test cases for product families is difficult due to variability in the requirements, since each variation point multiplies the number of possible behaviors to be tested. This paper proposes an approach to develop domain test cases from use cases that contain variabilities and to derive application test cases from them. The basic idea to avoid combinatorial explosion is to preserve the variability in domain test cases. New strategies to capture variability in test cases are suggested, which in combination help dealing with all basic types of variability in a use case and in its relationships (e.g., <>).

Abstract: This half-day tutorial gives an overview of the current state-of-the-art in software visualization. Software visualization encompasses the development and evaluation of methods for graphically representing different aspects of software, including its structure, its execution, and its evolution. In contrast to visual programming and diagramming for software design, software visualization is not so much concerned with the construction, but with the analysis of programs and their development process. Software visualization combines techniques from areas like software engineering, programming languages, data mining, computer graphics, information visualization and human-computer interaction. Topics covered in this tutorial include static program visualization, algorithm animation, visual debugging, as well as the visualization of the evolution of software. In particular we identify common principles illustrated by many examples and give pointers to tools available today.

Abstract: Cost, quality and lead-time are three main concerns in software engineering projects. The quality of developed software has traditionally been evaluated on completed systems. Evaluating the product quality at completion introduces a great risk of wasting effort on software products with inadequate system qualities. It is the objective of this thesis to define and study methods for assessment, evaluation and prediction of software systems’ modifiability characteristics based on their architecture designs. Since software architecture design is made early in the development, architecture evaluation helps detect inadequate designs and thus reduces the risk of implementing systems of insufficient quality. We present a method for architecture-level analysis of modifiability (ALMA) that analyses the modifiability potential of a software system based on its software architecture design. The method is scenario-based and either compares architecture candidates, assesses the risk associated with modifications of the architecture, or predicts the effort needed to implement anticipated modifications. The modification prediction results in three values; a prediction of the modification effort and the predicted best- and worst-case effort for the same system and change scenario profile. In this way the prediction method provides a frame-of-reference that supports the architect in the decision whether the modifiability is acceptable or not. The method is based on the experiences and results from one controlled experiment and seven case-studies, where five case studies are part of this thesis. The experiment investigates different ways to organize the scenario elicitation and finds that a group of individually prepared persons produce better profiles than individuals or unprepared groups.

Abstract: A key problem in software engineering is changing the code. We present a sequence of visualizations and visual metaphors designed to help engineers understand and manage the software change process. The principal metaphors are matrix views, cityscapes, bar and pie charts, data sheets and networks. Linked by selection mechanisms, multiple views are combined to form perspectives that both enable discovery of high-level structure in software change data and allow effective access to details of those data. Use of the views and perspectives is illustrated in two important contexts: understanding software change by exploration of software change data and management of software development. Our approach complements existing visualizations of software structure and software execution.