Search

The article presents information on the 20th anniversary of the IEEE International Conference on Software Maintenance (ICSM). Software maintenance and evolution continues to play a vital role in the development of software systems. For many years there has been an international effort among researchers and practitioners to control the costs associated with software maintenance and evolution and to improve the quality of the processes and products associated with this vital activity. Software maintenance encompasses human elements of software engineering, which require psychological, statistical, and empirical evaluation. It involves algorithms, methods, and techniques which require a deep understanding of all activities in the software development life cycle. Since its inception in 1983, ICSM has evolved into an international forum for researchers, practitioners, educators, technology transfer experts, project managers, tool developers, and users who explore current issues facing the computing community. In 2004, the ICSM program chairs, Mark Harman from King's College in London and Bogdan Korel from Illinois institute of Technology in Chicago, selected 38 papers for inclusion in the proceedings from 122 submissions.

When software engineers fix bugs, they may have several options as to how to fix those bugs. Which fix they choose has many implications, both for practitioners and researchers: What is the risk of introducing other bugs during the fix? Is the bug fix in the same code that caused the bug? Is the change fixing the cause or just covering a symptom? In this paper, we investigate alternative fixes to bugs and present an empirical study of how engineers make design choices about how to fix bugs. We start with a motivating case study of the Pex4Fun environment. Then, based on qualitative interviews with 40 engineers working on a variety of products, data from six bug triage meetings, and a survey filled out by 326 Microsoft engineers and 37 developers from other companies, we found a number of factors, many of them non-technical, that influence how bugs are fixed, such as how close to release the software is. We also discuss implications for research and practice, including how to make bug prediction and localization more accurate. [ABSTRACT FROM PUBLISHER]

The article provides an overview of the April 1988 issue of the periodical "IEEE Transactions on Software Engineering," which deals with computer languages and their related issues. In the first paper, Ryder and Pendergrast address language implementation. They discuss a globally optimizing complier for the functional programming language. Moreover, the study focuses on the intermediate language that is used by the FPOPT compiler for transformation and optimization. The second paper by Schwan, Rammath, Vasudevan and Ogle addresses a language for the parallel programming application domain. In addition to the language definition, the paper includes a description prototype system that was developed to support the language. Finally, Wolf, Clarke and Wileden's paper deals with visibility control in conventional higher-order programming languages. It includes the foundations for the visibility control mechanisms and the PIC approach in the context of visibility.

The article provides an introduction to this special issue related to software maintenance and evolution. The topics discussed in this issue were developed from papers presented at the International Conference on Software Maintenance and Evolution (ICSM), which was held in Budapest, Hungary from September 26-29, 2005; the articles focus on software maintenance and change. Topics such as reverse engineering, documenting, and programming computer software are discussed.

This issue of the "IEEE Transactions on Software Engineering" magazine contains seven of the papers presented at the seventh International Conference on Software Engineering (ICSE) held in Orlando, Florida in March 1984. The papers are: "Exception Handling: Formal Specification and Systematic Program Construction"; "Software Engineering for User Interfaces"; "The Modular Structure of Complex Systems"; "PROUST: Knowledge-Based Program Understanding"; "PECAN: Program Development Systems That Support Multiple Views"; "A Tour Through Cedar"; and "Steps to An Advanced Ada Programming Environment". All the papers represented the best in the state of the art, in surveying the past, and in speculation of future directions.

The time-cost behavior of a program directly depends on its execution environment (i.e., the number of other programs in the system). In this paper, we present techniques to analyze the time-cost behavior of programs that include the effect of their execution environment. It is assumed the underlying system has a shared memory architecture. The paper shows one can analytically relate a parallel program's time cost to its execution environment. A direct benefit of the work is to let us meet the real-time requirement of a parallel program and utilize maximally a multiprocessor system's resource. [ABSTRACT FROM AUTHOR]

In this paper we: 1) discuss the need for quantitatively reproducible experiments in the study of top-down design; 2) propose the design and writing of tutorial papers as a suitably general and in- expensive vehicle; 3) suggest the software science parameters as appropriate metrics; 4) report two experiments validating the use of these metrics on outlines and prose; and 5) demonstrate that the experiments tended toward the same optimal modularity. The last point appears to offer a quantitative approach to the estimation of the total length or volume (and the mental effort required to produce it) from an early stage of the top-down design process. If results of these experiments are validated elsewhere, then they will provide basic guidelines for the design process. [ABSTRACT FROM AUTHOR]

The paper "An Interval Logic for Real-Time System Specification" [5] presents the TILCO specification language and compares it to other existing similar languages. In this comment, we show that several of the logic formulas used for the comparison are flawed and/or overly complicated and we explain why, in this respect, the comparison is moot. [ABSTRACT FROM AUTHOR]

The demand for information processing-both in terms of volume of information and the variety of processing is insatiable and ever increasing. Many previously infeasible systems are expected naturally today. Basic physical limitations on electronic circuits have started to force high performance computations to be targeted toward the exploitation of parallelism. Just as the fastest cycle times are approaching the fundamental barriers imposed by physical device limitations, different kinds of parallel and distributed systems are emerging. It's only a matter of time before this trend will affect general purpose computing. The concept of parallelism, either at the architecture or the algorithm level, is a significant departure from the traditional sequential approach. In parallel processing, we save time by identifying concurrently executable subtasks in a given task and executing them on multiple processors simultaneously. At the same time, a parallel programming language defines an environment for the implementation effort directed to each parallel computer.

In this paper we study database query languages and their use for programming nontraditional applications, such as engineering and artificial intelligence applications. In such environments, database programs are used to code applications that work over large data sets it- siding in databases. Optimizing such programs then becomes a necessity. We look at various optimization techniques and suggest transformations to be used for Improving the performance of database programs. These transformations result in new equivalent database programs with better space and lime performance. Several of these techniques apply to classical query languages, although the primary focus of this paper is on extended query languages which include an iteration operator. [ABSTRACT FROM AUTHOR]

This paper describes facilities added to a conventional programming language that will manipulate streams of values. A stream is a sequence of values of a certain fixed type. The number of elements of a stream may be determined at execution time, and evaluation of each element can be postponed until its value is actually needed. Many programs can be expressed naturally and clearly as networks of processes communicating by means of streams. The network is called a composite function and consists of several component functions. Since component functions are connected solely by streams, they greatly increase the flexibility of combinations and the reusability of programs. Loop statements can be considered as iterative statements over streams. One general problem In these networks Is the mechanism of terminating each process of the network. This paper presents a practical solution for this problem. Comparisons to other programming styles, such as coroutines, Lisp, functional programming, and data flow languages, are described. Three modes of execution are considered for the implementation of composite functions: parallel mode, coroutine mode, and in-line mode. In the in- line mode, a composite function is expanded and transformed into a single function, realizing maximum run-time efficiency. Algorithms for this expansion are given. The language in this paper has been designed as an extension of Pascal. A subset of it has been implemented. [ABSTRACT FROM AUTHOR]

The use of icons is effective for attaining higher man-machine interaction in programming from the viewpoints of both universality and efficiency. In this paper, the authors propose a new framework for icon management and an iconic programming based on it. In the framework, icons represent real objects or the concepts already established in a target application environment, whereas icons representing functions are not provided. A function is represented by a combination of two different icons. Each icon can take an active or a passive role against the other. The role sharing is determined dynamically depending on the environment in which the icons are activated; The framework for icon management mentioned above, which is quite object-oriented, is first proposed, and then an iconic programming system named HI-VISUAL is presented on the basis of the framework. Programming in HI-VISUAL and implementational issues of the system prototype, now in actual operation in our laboratory environment, are extensively discussed. [ABSTRACT FROM AUTHOR]

For the development of communications software com- posed of many modules, protocol validation is essential to detect errors in the interactions among the modules. A number of protocol validation techniques were proposed in the past, but the validation time required by these techniques is too long for many actual protocols. This paper proposes a new fast protocol validation technique to overcome this drawback. The proposed technique is to construct the minimum acyclic form of state transitions in individual processes of the protocol, and to detect protocol errors such as system deadlocks and channel overflows fast. This paper also presents a protocol validation system based on the proposed technique to confirm its feasibility and shows validation results for some actual protocols obtained with this system. As a result, the protocol validation system is expected to contribute to a great extent to the improvement of the productivity in development and maintenance of communications software. [ABSTRACT FROM AUTHOR]

There has been a tremendous spurt in research and activity in image processing techniques and applications. This has been a productive endeavor in that it has revolutionized the state and art of technology in several diverse areas such as medical diagnostics, tactical sensing for defense applications, satellite image processing, and robotics vision systems. In order to take full advantage of the growing application spectrum in image processing, it is important to understand the fundamental concepts, principal characteristics, and implementation experience. In order to progress in image databases from a software engineering perspective, it is essential to examine innovations in both processing and representations of images.

Aspect-Oriented Programming (AOP) provides mechanisms for the separation of crosscutting concerns--functionalities scattered through the system and tangled with the base code. Existing systems are a natural test-bed for the AOP approach since they often contain several crosscutting concerns which could not be modularized using traditional programming constructs. This paper presents an automated approach to the problem of migrating systems developed according to the Object-Oriented Programming (OOP) paradigm into Aspect-Oriented Programming (AOP). A simple set of six refactorings has been defined to transform OOP to AOP and has been implemented in the AOP-Migrator tool, an Eclipse plug-in. A set of enabling transformations from OOP to OOP complement the initial set of refactorings. The paper presents the results of four case studies, which use the approach to migrate selected crosscutting concerns from medium-sized Java programs (in the range of 10K to 40K lines of code) into equivalent programs in AspectJ. The case study results show the feasibility of the migration and indicate the importance of the enabling transformations as a preprocessing step. [ABSTRACT FROM AUTHOR]

The article focuses on the current in exception handling, published in September 1, 2001 issue of IEEE Transactions on Software Engineering. Exception handling includes four papers which primarily handling in human-centered system such as workflow, such as workflow, requirement specification and new interactive programming models such as spreadsheets. These research contributions demonstrate that exceptions are not restricted to programming languages, but occur in many, if not most, real world situations. The programming models of spreadsheet systems raises many unique issues related to exception handling. This is a widely used model of programming by end users through the use of many commercial products. A paper on handling irregularities in human centered systems, published in the issue addresses exception handling problems in human centered systems. In such systems, exception handling is required for dealing with errors, as well as deviations, in data as well as processes, from their normal constraints.

Introduces the December 1992 issue of the "IEEE Transactions of Software Engineering," which covers software maintenance. The issue gives a glimpse of the vigorous research in this area. The first two papers deal with the topic of object-oriented program maintenance. The third paper deals with a software tool that is based on the static analysis of code, its representation in a Prolog dictionary, and Prolog abstractor that allows specific queries to be answered. The final paper deals with the recognition and extraction of programming concepts from the programs. It focuses on the techniques of program transformations, and uses them for the reverse engineering of the program.

This paper describes a formal approach to developing concurrent rule-based programs. Our program derivation strategy starts with a formal specification of the problem. Specification refinement is used to generate an initial version of the program. Program refinement is then applied to produce a highly concurrent and efficient version of the same program. Techniques for deriving concurrent programs through either specification or program refinement have been described in previous literature. The main contribution of this paper consists of extending the applicability of these techniques to rule-based programs. The derivation process is supported by a powerful proof logic, a logic that recently has been extended to cover rule- based programs. The presentation centers around a rigorous and systematic derivation of a concurrent rule-based solution to a classic problem. [ABSTRACT FROM AUTHOR]

In engineering applications, multiple copies of object descriptions have to coexist in a single database. This paper proposes a scheme that enables users to explicitly deal with these object versions. After introducing a basic version model, the problem of "rerouting" interobject references upon the creation of new versions is solved by providing generic references and user-specific environments. Finally, logical version clusters are introduced that allow for the meaningful grouping of versions. The paper concludes with some remarks on implementation and a comparison with other approaches. [ABSTRACT FROM AUTHOR]

The art of programming is taught, learned, and often practiced as if programs are disposable, personal objects owned solely by the programmer. This paper uses examples to illustrate why real software is neither personal nor disposable; it shows how even simple programs are shared by others. From the examples, the paper extracts four principles for program development. Finally, it thaws conclusions about programming practices and the education of programmers. [ABSTRACT FROM AUTHOR]

This paper presents a specification language, implementation mechanism, and proof techniques for problems involving the arbitration of concurrent requests to shared protected resources whose integrity must be preserved. This mechanism is the serializer, which may be described as a kind of protection mechanism, in that it prevents improper orders of access to a protected resource. Serializers are a more structured form of the monitor mechanism of Brinch Hansen and bare. Serializers attempt to systematize and abstract desirable features of synchronization control structure into a coherent language construct. Serializers have better synchronization modularity than monitors in several respects. Monitors synchronize requests by providing a pair of operations for each request type (examples are STARTREAD/ENDREAD and STARTWRITE/ENDWRITE for the readers-writers problems). Such a pair of operations must be used in a certain order for the synchronization to work properly, yet nothing in the monitor construct enforces this use. Serializers incorporate this structural aspect of synchronization in a unified mechanism to guarantee proper check-in and check-out by encasing the resource inside the serializer. Thus a serializer for a readers-writers problem provides only two entry points for external users: READ(directions) and WRITE(directions) where the directions are passed to the resource. In scheduling access to a protected resource, it is often necessary that a process wait for a certain condition before continuing execution. Monitors require that a process waiting will remain dormant forever, unless another process explicitly signals the dormant process that it should continue. Serializers improve the modularity of synchronization by providing that the condition for resuming execution must be explicitly stated when a process waits, making it unnecessary for processes to signal other processes. That is, the serializer decides for each process the conditions required for the further execution of the process. The behavior of a serializer is defined axiomatically in terms of the precedes relation among events using the actor message-passing model of computation [11], [10], [16], [1]. Different versions of the "readers-writers" problems are used in this paper to illustrate how the structure of a serializer corresponds in a natural way to the structure of the specification of synchronization problems. In this paper we present specification and proof techniques using partial others on computational events for dealing with problems involving fairness, starvation, and guaranteed concurrency. Our techniques represent a significant advance over previously developed techniques using global states. [ABSTRACT FROM AUTHOR]

Basic error recovery problems between interacting processes are first discussed and the desirability of having separate recovery mechanisms for cooperation and competition is demonstrated. The paper then concentrates on recovery mechanisms for processes competing for the use of the shared resources of a computer system. Appropriate programming language features are developed based on the class and inner features of SIMULA, and on the structuring concepts of recovery blocks and monitors. [ABSTRACT FROM AUTHOR]

In this Special Issue on Microprogamming, five papers are included which deal with the various software engineering aspects of microprogramming. The paper by Werner Damm describes a universal syntax-directed proof system for the verification of horizontal microprograms. The paper by Mueller et al. provides a description of a comprehensive retargetable compiler for horizontal microcodes. Aiken and Nicolau report on a system that automatically identifies parallel microoperations and generates horizontal microinstructions. The paper by Allan and Mueller addresses an important problem on microcode compaction which is the consideration of timing constraints. The paper by Winner provides an object-oriented view of vertical migration in dynamic microprogramming.

Although the principles of gossip protocols are relatively easy to grasp, their variety can make their design and evaluation highly time consuming. This problem is compounded by the lack of a unified programming framework for gossip, which means developers cannot easily reuse, compose, or adapt existing solutions to fit their needs, and have limited opportunities to share knowledge and ideas. In this paper, we consider how component frameworks, which have been widely applied to implement middleware solutions, can facilitate the development of gossip-based systems in a way that is both generic and simple. We show how such an approach can maximize code reuse, simplify the implementation of gossip protocols, and facilitate dynamic evolution and redeployment. id="fnote1" asterisk="no"paraAlso known as “epidemic” protocols. para [ABSTRACT FROM PUBLISHER]

Modern programming environments provide extensive support for inspecting, analyzing, and testing programs based on the algorithmic structure of a program. Unfortunately, support for inspecting and understanding runtime data structures during execution is typically much more limited. This paper provides a general purpose technique for abstracting and summarizing entire runtime heaps. We describe the abstract heap model and the associated algorithms for transforming a concrete heap dump into the corresponding abstract model as well as algorithms for merging, comparing, and computing changes between abstract models. The abstract model is designed to emphasize high-level concepts about heap-based data structures, such as shape and size, as well as relationships between heap structures, such as sharing and connectivity. We demonstrate the utility and computational tractability of the abstract heap model by building a memory profiler. We use this tool to identify, pinpoint, and correct sources of memory bloat for programs from DaCapo. [ABSTRACT FROM PUBLISHER]

Workloads and resource usage patterns in enterprise applications often show burstiness resulting in large degradation of the perceived user performance. In this paper, we propose a methodology for detecting burstiness symptoms in multi-tier applications but, rather than identifying the root cause of burstiness, we incorporate this information into models for performance prediction. The modeling methodology is based on the index of dispersion of the service process at a server, which is inferred by observing the number of completions within the concatenated busy times of that server. The index of dispersion is used to derive a Markov-modulated process that captures burstiness and variability of the service process at each resource well and that allows us to define queueing network models for performance prediction. Experimental results and performance model predictions are in excellent agreement and argue for the effectiveness of the proposed methodology under both bursty and nonbursty workloads. Furthermore, we show that the methodology extends to modeling flash crowds that create burstiness in the stream of requests incoming to the application. [ABSTRACT FROM PUBLISHER]

In this paper, we explore the concept of code readability and investigate its relation to software quality. With data collected from 120 human annotators, we derive associations between a simple set of local code features and human notions of readability. Using those features, we construct an automated readability measure and show that it can be 80 percent effective and better than a human, on average, at predicting readability judgments. Furthermore, we show that this metric correlates strongly with three measures of software quality: code changes, automated defect reports, and defect log messages. We measure these correlations on over 2.2 million lines of code, as well as longitudinally, over many releases of selected projects. Finally, we discuss the implications of this study on programming language design and engineering practice. For example, our data suggest that comments, in and of themselves, are less important than simple blank lines to local judgments of readability. [ABSTRACT FROM AUTHOR]

In this paper, we present a forward recovery model for programming robust context-aware applications. The mechanisms devised as part of this model fall into two categories: asynchronous event handling and synchronous exception handling. These mechanisms enable designing recovery actions to handle different kinds of failure conditions arising in context-aware applications. These include service discovery failures, service binding failures, exceptions raised by a service, and context invalidations. This model is integrated in the high-level programming framework that we have designed for building context-aware collaborative (CSCW) applications. In this paper, we demonstrate the capabilities of this model for programming various kinds of recovery patterns in contextaware applications. [ABSTRACT FROM AUTHOR]

Program comprehension is an important activity in software maintenance, as software must be sufficiently understood before it can be properly modified. The study of a program's execution, known as dynamic analysis, has become a common technique in this respect and has received substantial attention from the research community, particularly over the last decade. These efforts have resulted in a large research body of which currently there exists no comprehensive overview. This paper reports on a systematic literature survey aimed at the identification and structuring of research on program comprehension through dynamic analysis. From a research body consisting of 4,795 articles published in 14 relevant venues between July 1999 and June 2008 and the references therein, we have systematically selected 176 articles and characterized them in terms of four main facets: activity, target, method, and evaluation. The resulting overview offers insight in what constitutes the main contributions of the field, supports the task of identifying gaps and opportunities, and has motivated our discussion of several important research directions that merit additional consideration in the near future. [ABSTRACT FROM AUTHOR]

In this paper, we first present an exploratory analysis of the aspects of multiple-version software diversity using 36,123 programs written to the same specification. We do so within the framework of the theories of Eckhardt and Lee and Littlewood and Miller. We analyze programming faults made, explore failure regions and difficulty functions, and show how effective 1-out-of-2 diversity is and how language diversity increases this effectiveness. The second part of this paper generalizes the findings about 1-out-of-2 diversity and its special case language diversity by performing statistical analyses of 89,402 programs written to 60 specifications. Most observations in the exploratory analysis are confirmed; however, although the benefit of language diversity can be observed, its effectiveness-appears to be low. [ABSTRACT FROM AUTHOR]

Little is known about the specific kinds of questions programmers ask when evolving a code base and how well existing tools support those questions. To better support the activity of programming, answers are needed to three broad research questions: 1) What does a programmer need to know about a code base when evolving a software system? 2) How does a programmer go about finding that information? 3) How well do existing tools support programmers in answering those questions? We undertook two qualitative studies of programmers performing change tasks to provide answers to these questions. In this paper, we report on an analysis of the data from these two user studies. This paper makes three key contributions. The first contribution is a catalog of 44 types of questions programmers ask during software evolution tasks. The second contribution is a description of the observed behavior around answering those questions. The third contribution is a description of how existing deployed and proposed tools do, and do not, support answering programmers' questions. [ABSTRACT FROM AUTHOR]

System performance is a key factor to take into account throughout the software life cycle of modern computer systems, mostly due to their typical characteristics such as distributed deployment, code mobility, and platform heterogeneity. An open challenge in this direction is to integrate the performance validation as a transparent and efficient activity in the system development process. Several methodologies have been proposed to automate the transformation of software/hardware models into performance models. In this paper, we do not take a transformational approach; rather, we present a framework to integrate a software model with a platform model in order to build a performance model. Performance indices are obtained from simulation of the resulting performance model. Our framework provides a library of predefined resource models, model annotation and integration procedures, and simulation support that makes the performance analysis a much easier activity. We present the results obtained from two different industrial case studies that show the maturity and the stability of our approach. [ABSTRACT FROM AUTHOR]

Design by contract is a lightweight technique for embedding elements of formal specification (such as invariants, pre and postconditions) into an object-oriented design. When Contracts are made executable, they can play the role of embedded, online oracles. Executable contracts allow components to be responsive to erroneous states and, thus, may help in detecting and locating faults. In this paper, we define Vigilance as the degree to which a program is able to detect an erroneous state at runtime. Diagnosability represents the effort needed to locate a fault once it has been detected. In order to estimate the benefit of using Design by Contract, we formalize both notions of Vigilance and Diagnosability as software quality measures. The main steps of measure elaboration are given, from informal definitions of the factors to be measured to the mathematical model of the measures. As is the standard in this domain, the parameters are then fixed through actual measures, based on a mutation analysis in our case. Several measures are presented that reveal and estimate the contribution of contracts to the overall quality of a system in terms of vigilance and diagnosability. [ABSTRACT FROM AUTHOR]

Constructing runtime tasks, or operating system-level processes/threads, from the components of software design models is crucial to the model-based development of embedded control software. A better method should explore more design choices and reduce the overheads of the runtime system to meet the timing and resource constraints of embedded control software. This paper presents a novel, two-step method for systematic and automated construction of runtime tasks from software design models. It uses graph transformation to construct a task set meeting system-level end-to-end (e2e) timing constraints. Its first step decomposes the system-level e2e timing constraints into the components' timing constraints, which form a necessary condition for any valid and feasible schedule. The second step iteratively merges the components into tasks and sequences their executions. A thus-constructed task set is proven to meet both intercomponent precedence and system-level e2e timing constraints and to minimize runtime overheads by minimizing the total number of resultant tasks. Our evaluation results based on randomly generated software models have shown that the proposed method outperforms commonly used methods and is also scalable. [ABSTRACT FROM AUTHOR]

In systems developed without aspect-oriented programming, code implementing a crosscutting concern may be spread over many different parts of a system. Identifying such code automatically could be of great help during maintenance of the system. First of all, it allows a developer to more easily find the places in the code that must be changed when the concern changes and, thus, makes such changes less time consuming and less prone to errors. Second, it allows the code to be refactored to an aspect-oriented solution, thereby improving its modularity. In this paper, we evaluate the suitability of clone detection as a technique for the identification of crosscutting concerns. To that end, we manually identify five specific crosscutting concerns in an industrial C system and analyze to what extent clone detection is capable of finding them. We consider our results as a stepping stone toward an automated "aspect miner" based on clone detection. [ABSTRACT FROM AUTHOR]

Information Systems are situated in and are representations of some business or organizational domain. Hence, understanding the application domain is critical to the success of information systems development. To support domain understanding, the application domain is represented in conceptual models. The correctness of conceptual models can affect the development outcome and prevent costly rework during later development stages. This paper proposes a method to restrict the syntax of a modeling language to ensure that only possible configurations of a domain can be modeled, thus increasing the likelihood of creating correct domain models. The proposed method, based on domain ontologies, captures relationships among domain elements via constraints on the language metamodel, thus restricting the set of statements about the domain that can be generated with the language. In effect, this method creates domain specific modeling languages from more generic ones. The method is demonstrated using the Unified Modeling Language (UML). Specifically, it is applied to the subset of UML dealing with object behavior and its applicability is demonstrated on a specific modeling example. [ABSTRACT FROM AUTHOR]

This paper describes a program representation and algorithms for realizing a novel structural testing methodology that not only focuses on addressing the complex features of object-oriented languages, but also incorporates the structure of object-oriented software into the approach. The testing methodology is based on the construction of contextual def-use associations, which provide context to each definition and use of an object. Testing based on contextual def-use associations can provide increased test coverage by identifying multiple unique contextual def-use associations for the same context-free association. Such a testing methodology promotes more thorough and focused testing of the manipulation of objects in object-oriented programs. This paper presents a technique for the construction of contextual def-use associations, as well as detailed examples illustrating their construction, an analysis of the cost of constructing contextual def-use associations with this approach, and a description of a prototype testing tool that shows how the theoretical contributions of this work can be useful for structural test coverage. [ABSTRACT FROM AUTHOR]

In this paper, we propose a means to enhance an architecture description language with a description of component behavior. A notation-used for this purpose should be able to express the "interplay" on the component's interfaces and reflect step-bystep refinement of the component's specification during its design. In addition, the notation should be easy to comprehend and allow for formal reasoning about the correctness of the specification refinement and also about the correctness of an implementation in terms of whether it adheres to the specification. Targeting all these requirements together, the paper proposes employing behavior protocols which are based on a notation similar to regular expressions. As proof of the concept, the behavior protocols are used in the SOFA architecture description language at three levels: interface, frame, and architecture. Key achievements of this paper include the definitions of bounded component behavior and protocol conformance relation. Using these concepts, the designer can verify the adherence of a component's implementation to its specification at runtime, while the correctness of refining the specification can be verified at design time. [ABSTRACT FROM AUTHOR]

This paper presents an approach to the schedulability analysis of real-time systems modeled in time Petri nets by separating timing properties from other behavioral properties. The analysis of behavioral properties is conducted based on the reachability graph of the underlying Petri net, whereas timing constraints are checked in terms of absolute and relative firing domains. If a specific task execution is schedulable, we calculate the time span of the task execution, and pinpoint nonschedulable transitions to help adjust timing constraints. A technique for compositional timing analysis is also proposed to deal with complex task sequences, which not only improves efficiency but also facilitates the discussion of the reachability issue with regard to schedulability. We have identified a class of well-structured time Petri nets such that their reachability can be easily analyzed. [ABSTRACT FROM AUTHOR]

Although there has been recent research into ways to design environments that enable end users to create their own programs, little attention has been given to helping these end users systematically test their programs. To help address this need in spreadsheet systems--the most widely used type of end-user programming language--we previously introduced a visual approach to systematically testing individual cells in spreadsheet systems. However, the previous approach did not scale well in the presence of largely homogeneous grids, which introduce problems somewhat analogous to the array-testing problems of imperative programs. In this paper, we present two approaches to spreadsheet testing that explicitly support such grids. We present the algorithms, time complexities, and performance data comparing the two approaches. This is part of our continuing work to bring to end users at least some of the benefits of formalized notions of testing without requiring knowledge of testing beyond a naive level. [ABSTRACT FROM AUTHOR]

In the paper, "Temporal Logic-Based Deadlock Analysis for Ada," reference [9] was duplicated as reference [10], causing the remaining references to be misnumbered by one. The correctly numbered reference list is given below in its entirety. All reference citations in the paper's text are correct as published.

The field of transformations is developing a methodology for manipulating programs, mapping them from one form into another. Transforming a program will preserve some of its properties, and alter others. While many choices could be made about which properties to preserve, the transformation field has focused on altering the performance characteristics of programs while preserving their 'semantics.' The papers published in the January 1981 issue of the periodical "IEEE Transactions on Software Engineering" are necessarily limited. Many of the important topics are not trated. The papers were selected to present a flavor for some aspects of the transformation field and to illustrate some research.

The availability of significant measures in the early phases of the software development life-cycle allows for better management of the later phases, and more effective quality assessment when quality can be more easily affected by preventive or corrective actions. In this paper, we introduce and compare various high-level design measures for object-based software systems. The measures are derived based on an experimental goal, identifying fault-prone software parts, and several experimental hypotheses arising from the development of Ada systems for Flight Dynamics Software at the NASA Goddard Space Flight Center (NASA/GSFC). Specifically, we define a set of measures for cohesion and coupling, which satisfy a previously published set of mathematical properties that are necessary for any such measures to be valid. We then investigate the measures' relationship to fault-proneness on three large scale projects, to provide empirical support for their practical significance and usefulness. [ABSTRACT FROM AUTHOR]

Experimentation in software engineering is necessary but difficult. One reason is that there are a large number of context variables and, so, creating a cohesive understanding of experimental results requires a mechanism for motivating studies and integrating results. It requires a community of researchers that can replicate studies, vary context variables, and build models that represent the common observations about the discipline. This paper discusses the experience of the authors, based upon a collection of experiments, in terms of a framework for organizing sets of related studies. With such a framework, experiments can be viewed as part of common families of studies, rather than being isolated events. Common families of studies can contribute to important and relevant hypotheses that may not be suggested by individual experiments. A framework also facilitates building knowledge in an incremental manner through the replication of experiments within families of studies. To support the framework, this paper discusses the experiences of the authors in carrying out empirical studies, with specific emphasis on persistent problems encountered in experimental design, threats to validity, criteria for evaluation, and execution of experiments in the domain of software engineering. [ABSTRACT FROM AUTHOR]

With the approach of the new millennium, a primary focus in software engineering involves issues relating to upgrading, migrating, and evolving existing software systems. In this environment, the role of careful empirical studies as the basis for improving software maintenance processes, methods, and tools is highlighted. One of the most important processes that merits empirical evaluation is software evolution. Software evolution refers to the dynamic behavior of software systems as they are maintained and enhanced over their lifetimes. Software evolution is particularly important as systems in organizations become longer-lived. However, evolution is challenging to study due to the longitudinal nature of the phenomenon in addition to the usual difficulties in collecting empirical data. In this paper, we describe a set of methods and techniques that we have developed and adapted to empirically study software evolution. 0ur longitudinal empirical study involves collecting, coding, and analyzing more than 25,000 change events to 23 commercial software systems over a 20-year period. Using data from two of the systems, we illustrate the efficacy of flexible phase mapping and gamma sequence analytic methods originally developed in social psychology to examine group problem solving processes. We have adapted these techniques in the context of our study to identify and understand the phases through which a* software system travels as it evolves over time. We contrast this approach with time series analysis, the more traditional way of studying longitudinal data. Our work demonstrates the advantages of applying methods and techniques from other domains to software engineering and illustrates how, despite difficulties, software evolution can be empirically studied. [ABSTRACT FROM AUTHOR]

Empirical software engineering can be viewed as a series of actions to obtain knowledge and a better understanding about some aspects of software development given a set of problem statements in the form of issues, questions or hypotheses. Our experience in conducting empirical software engineering from a variety of viewpoints for the last decade has made us aware of the criticality of integrating the various types of data that are collected and analyzed as well as the criticality of integrating the various types of activities that take place such as experiment design and the experiment itself. This has led us to develop a Computer-Aided Empirical Software Engineering (CAESE) framework as a substrate for supporting the empirical software engineering lifecycle. CAESE supports empirical software engineering in the same manner as a CASE environment serves as a substrate for supporting the software development lifecycle. This paper first presents the CAESE framework that consists of three elements. The first element is a process model for the "lifecycle" of empirical software engineering studies, including needs analysis, experiment design, actual experimentation, and analyzing and packaging results. The second element is a model that helps empirical software engineers decide how to look at the "world" to be studied in a coherent manner. The third element is an architecture based on which CAESE environments can be built, consisting of tool sets for each phase of the process model, a process management mechanism, and the two types of integration mechanism that are vital for handling multiple types of data: data integration and control integration. The second half of this paper describes the Ginger2 environment as an instantiation of our framework. The paper concludes with reports on case studies using Ginger2, which dealt with a variety of empirical data types including mouse and keystrokes, eye traces, three- dimensional movement, skin resistance level, and video-taped data. [ABSTRACT FROM AUTHOR]

Mathematical software is devoted to solve problems involving matrix computation and manipulation. The main problem limiting the reusability of existing mathematical software is the following: programs are often not initially designed for being reused. Therefore, it is hard to find programs that can be easily reused. In the first part of this paper, we give a programming methodology useful for designing and implementing reusable code. We name unit a portion of code designed and implemented for being reused. Our units are self-contained software components featuring a high degree of information hiding. This way of organizing software facilitates the reuse process and, furthermore, improves the understandability of units. To speed up the implementation process, a system supporting the reusability of units from an existing software library is particularly useful. In the second part of this paper, we report about an easy to use system of this kind. [ABSTRACT FROM AUTHOR]

We review propagation patterns for describing object-oriented software at a higher level of abstraction than the one used by today's programming languages. A propagation pattern defines a family of programs from which we can select a member by giving a class dictionary graph that details the structure of behavior through part-of and inheritance relationships between classes. The paper introduces three concepts: evolution histories, growth-plans and a propagation- directive calculus. Evolution histories describe a sequence of development phases of an object-oriented program, each phase being executable and therefore testable. To keep the programs flexible and short, we describe them in terms of propagation patterns. Each phase of an evolution history is tested in small steps that are constrained by class, dictionary graphs belonging to a growth-plan. Propagation directives are useful both for describing propagation patterns and growth-plans, and therefore we endow propagation directives with sufficient expressiveness by giving a formal calculus applicable to object- oriented programming in general. A propagation directive is a succinct description of a family of submodels for a given family of data models. [ABSTRACT FROM AUTHOR]

This paper describes the design, implementation, and experimental evaluation of a multiprocessor scheduler used with robotics applications and other real-time programs. The scheduler makes decisions concerning both the assignment of processes and the scheduling of those processes on each processor such that a near optimal number of process deadlines is satisfied. It assumes that process execution times, deadlines, and earliest possible start times are known. [ABSTRACT FROM AUTHOR]

An execution of a concurrent program P with input X nondeterministically exercises a sequence of synchronization events, called a synchronization sequence (or SYN-sequence). Thus, multiple executions of P with the same input X may exercise different SYN-sequences and produce different results. When debugging an erroneous execution of P with input X, it is often necessary to repeat this execution in order to collect more debugging information. However, there Is no guarantee that this execution will be repeated by executing P with input X. To solve this problem requires deterministic execution debugging, which is to force a deterministic execution of a concurrent program according to the SYN- sequence of a previous execution of this program. In this paper, we present a language-based approach to deterministic execution debugging of concurrent Ada programs. Our approach is to define SYN-sequences of a concurrent Ada program in terms of Ada language constructs and to replay such SYN-sequences without the need of system-dependent debugging tools. We first show how to define a SYN-sequence of a concurrent Ada program in order to provide sufficient Information for deterministic execution. Then we show how to transform a concurrent Ada program p so that the SYN-sequences of previous executions of P can be replayed. This transformation adds an Ada task to P that controls program execution by synchronizing with the original tasks in P. We also briefly describe the implementation of tools supporting deterministic execution debugging of concurrent Ada programs. [ABSTRACT FROM AUTHOR]