Search

Context: Several text books and papers published between 2000 and 2002 have attempted to introduce experimental design and statistical methods to software engineers undertaking empirical studies. Objective: This paper investigates whether there has been an increase in the quality of human-centric experimental and quasi-experimental journal papers over the time period 1993 to 2010. Method: Seventy experimental and quasi-experimental papers published in four general software engineering journals in the years 1992-2002 and 2006-2010 were each assessed for quality by three empirical software engineering researchers using two quality assessment methods (a questionnaire-based method and a subjective overall assessment). Regression analysis was used to assess the relationship between paper quality and the year of publication, publication date group (before 2003 and after 2005), source journal, average coauthor experience, citation of statistical text books and papers, and paper length. The results were validated both by removing papers for which the quality score appeared unreliable and using an alternative quality measure. Results: Paper quality was significantly associated with year, citing general statistical texts, and paper length (p < 0.05). Paper length did not reach significance when quality was measured using an overall subjective assessment. Conclusions: The quality of experimental and quasi-experimental software engineering papers appears to have improved gradually since 1993. [ABSTRACT FROM PUBLISHER]

Background: The accurate prediction of where faults are likely to occur in code can help direct test effort, reduce costs, and improve the quality of software. Objective: We investigate how the context of models, the independent variables used, and the modeling techniques applied influence the performance of fault prediction models. Method: We used a systematic literature review to identify 208 fault prediction studies published from January 2000 to December 2010. We synthesize the quantitative and qualitative results of 36 studies which report sufficient contextual and methodological information according to the criteria we develop and apply. Results: The models that perform well tend to be based on simple modeling techniques such as Naive Bayes or Logistic Regression. Combinations of independent variables have been used by models that perform well. Feature selection has been applied to these combinations when models are performing particularly well. Conclusion: The methodology used to build models seems to be influential to predictive performance. Although there are a set of fault prediction studies in which confidence is possible, more studies are needed that use a reliable methodology and which report their context, methodology, and performance comprehensively. [ABSTRACT FROM AUTHOR]

This paper aims to provide a basis for the improvement of software estimation research through a systematic review of previous work. The review identifies 304 software cost estimation papers in 76 journals and classifies the papers according to research topic, estimation approach, research approach, study context and data set. A Web-based library of these cost estimation papers is provided to ease the identification of relevant estimation research results. The review results combined with other knowledge provide support for recommendations for future software cost estimation research, including 1) increase the breadth of the search for relevant studies, 2) search manually for relevant papers within a carefully selected set of journals when completeness is essential, 3) conduct more studies on estimation methods commonly used by the Software industry, and 4) increase the awareness of how properties of the data sets impact the results when evaluating estimation methods. [ABSTRACT FROM AUTHOR]

The International Computer and Software Applications Conference has celebrated its tenth anniversary in 1986. The conference has been very successful in attracting excellent papers and panels from both academia and industry. It continued the tradition and attracted superb papers for the following tracks: software quality, software engineering, software requirements, development environments, software techniques and knowledge-based systems.

Context. Although research in software engineering largely seeks to improve the practices and products of software development, many practices are based upon codification of expert knowledge, often with little or no underpinning from objective empirical evidence. Software design patterns seek to codify expert knowledge to share experience about successful design structures. Objectives. To investigate how extensively the use of software design patterns has been subjected to empirical study and what evidence is available about how and when their use can provide an effective mechanism for knowledge transfer about design. Method. We conducted a systematic literature review in the form of a mapping study, searching the literature up to the end of 2009 to identify relevant primary studies about the use of the 23 patterns catalogued in the widely referenced book by the “Gang of Four.” These studies were then categorized according to the forms of study employed, the patterns that were studied, as well as the context within which the study took place. Results. Our searches identified 611 candidate papers. Applying our inclusion/exclusion criteria resulted in a final set of 10 papers that described 11 instances of “formal” experimental studies of object-oriented design patterns. We augmented our analysis by including seven “experience” reports that described application of patterns using less rigorous observational forms. We report and review the profiles of the empirical evidence for those patterns for which multiple studies exist. Conclusions. We could not identify firm support for any of the claims made for patterns in general, although there was some support for the usefulness of patterns in providing a framework for maintenance, and some qualitative indication that they do not help novices learn about design. For future studies we recommend that researchers use case studies that focus upon some key patterns, and seek to identify the impact that their use can have upon maintenance. [ABSTRACT FROM PUBLISHER]

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.

The article presents an editorial that reflects on the author's role as editor-in-chief of the journal "IEEE Transactions on Software Engineering." He remarks that the journal encourages those involved in the field of software engineering to submit manuscripts for publication. There is no longer a length limit to papers published in the journal. The reviewing process for submitted papers is discussed. The author discusses members of the journal's editorial board and offers his thanks to those who have helped in his role at the journal.

The article presents introduction to the April 2005 issue of the journal "IEEE Transactions on Software Engineering."

The article discusses various reports published within the issue, including one by Ray-Yaung Chang, Andy Podgurski, and Jiong Yang on discovering neglected conditions in computer software by mining dependence graphs, one by Marcelo d'Amorim, Steven Lauterburg, and Darko Marinov on speeding up state-space exploration, and one by Graham Hughes and Tevfik Bultan on interface grammars for modular software model checking.

This editorial introduces the January 1985 issue of "IEEE Transactions of Software Engineering," which publication on a monthly basis. The journal will have four major sections. One will contain in-depth research and survey papers on industrial experiences and approaches. The second section will contain short concise papers which will provide a fast review and publication of emerging research ideas and contain brief discussions of research ideas and experiences. The third category will be correspondence items which will primarily be opinions, comments, and/or rebuttals on papers published in the journal or elsewhere. The fourth section, "Calls for Papers," will inform the readers of the topics of the special issues, the names and addresses of the Guest Editors, and the submission deadlines.

We respond to criticism by D. Berry and W. Tichy of our paper that appeared in the March 2002 issue of IEEE Transactions on Software Engineering. Many of the supposed faults they identify in our experiment are a result of a misunderstanding on their part, while others are inherent aspects of an educational experiment. We present counterarguments that explain why our experiment is valid. [ABSTRACT FROM AUTHOR]

We comment on the experimental design and the result of the paper mentioned in the title. Our purpose is to show interested readers examples of what can go wrong with experiments in software research and how to avoid the attending problems. [ABSTRACT FROM AUTHOR]

The article presents an introduction of article of a special section published in the September 1998 issue of the journal "IEEE Transactions on Software Engineering." The author says that this special section contains extended versions three papers presented at the joint meeting of the Sixth European Software Engineering Conference (ESEC) and Fifth ACM SIGSOFT Symposium on the Foundations of Software Engineering (FSE), held at Zurich, Switzerland in September 1997. The program committee selected 27 papers out of the 194 submitted. ESEC and FSE conferences cover a broad range of topics in software engineering and have a highly technical focus. The first paper "A C++ Data Model Supporting Reachability Analysis and Dead Code Detection," discusses a C++ data model that is the foundation of many program analysis tools. The second paper "Integration of Sequential Scenarios," deals with scenarios that are used to document user-system interactions in system requirements and functional specifications. The third paper "Subtypes for Specifications: Predicate Subtyping in PVS," uses examples to show the utility of predicate subtypes in the specification language program verification system.

Analysis techniques, such as control flow, data flow, and control dependence, are used for a variety of software engineering tasks, including structural and regression testing, dynamic execution profiling, static and dynamic slicing, and program understanding. To be applicable to programs in languages such as Java and C++, these analysis techniques must account for the effects of exception occurrences and exception handling constructs; failure to do so can cause the analysis techniques to compute incorrect results and, thus, limit the usefulness of the applications that use them. This paper discusses the effects of exception handling constructs on several analysis techniques. The paper presents techniques to construct representations for programs with explicit exception occurrences-exceptions that are raised explicitly through throw statements-and exception handling constructs. The paper presents algorithms that use these representations to perform the desired analyses. The paper also discusses several software engineering applications that use these analyses. Finally, the paper describes empirical results pertaining to the occurrence of exception handling constructs in Java programs and their effect on some analysis tasks. [ABSTRACT FROM AUTHOR]

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]

Presents an introduction to the articles published in the June 2005 issue of the journal "IEEE Transactions on Software Engineering."

Introduces a special issue of the magazine 'IEEE Transactions on Software Engineering' (TSE) that features papers presented at the 2001 Workshop on Inspection in Software Engineering. Reasons behind the decision to feature the workshop papers in linked special issues of TSE and 'IEEE Software Magazine'; Definition of software inspection; Benefits of inspection.

The article introduces the September 2000 issue of the journal, IEEE Transactions on Software Engineering. The importance of exception handling is well-recognized by system designers and software engineers. Exception handling is very often the most important part of the system because it deals with abnormal situations. This special issue of the journal concentrates on exception handling. Out of 39 submissions of paper on exception handling 9 articles were selected for publication in this journal. These papers represent the important research directions and issues in exception handling in a broad range of disciplines, such as operating system, programming languages, workflow systems and spreadsheet programs. This special issue is published in two parts. The first part includes papers which focus on traditional issues which focus on traditional issues related to programming languages, program design testing and empirical studies.

Comments on the articles in the "IEEE Transactions on Software Engineering" were given. The periodical has an established, published scope which is subject to change as the file develops. Part of the review process is to state whether the paper meets the criteria. The scope should be limited to papers of interest to the software engineering community. However, besides mainstream software engineering topics, it could include the software engineering of various applications.

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.

An editorial is presented by Jeff Kramer, the new Editor-in-Chief of the "IEEE Transactions on Software Engineering" (TSE) journal, regarding the publications future. A vision statement is presented for the new issues and applications that face the computer engineering industry, and plans are offered to strengthen the Editorial Board. Three proposals are offered to improve the quality of TSE papers, including inviting submissions, being flexible with innovative papers that require further improvements, and the use of case studies.

The article reports on the International Conference on Software Engineering (ICSE) 2003 held in Portland, Oregon. The article discusses three papers that were selected for representing the best of ICSE 2003. The first paper "Scaling Step Wise Refinement," by D. Batory, J.N. Sarvela and A. Rauschmayer, is about development of computer software. The second paper is "Fragment Class Analysis for Testing of Polymorphism in Java Software" by A. Rountev, A. Milanova and B.C. Ryder, and the third paper is "Modular Verification of Software Components in C," by S. Chaki, F. Clarke, A. Groce, S. Jha and H. Veith. These two papers concern validation of software. The article also names some persons who devoted their time and energy in organizing ICSE 2003. The author suggests that managing the complexity of modern software systems is a grand challenge. Throughout the conference, there were exhibits, posters and informal research demonstrations as well as an onsite newsletter describing memorable moments, humor and fascinating facts.

Introduces the articles in the February 2003 issue of the journal 'Software Engineering' which was presented in the '23rd International Conference on Software Engineering.' Impact of software engineering on world economy; Coverage of the program; Selection of presented papers for publication in the journal.

Software metrics have matured considerably during the last decade. There is still a lot to be done, but the progress during the last decade is obvious. The field has moved from being very much focused on measurement as such, for example, proposing new metrics, to study the application of measurement in software engineering, for example, empirical studies evaluating some method or technique. The pressure on delivering software products with the right functionality, on time, within budget and with the right quality means that there is a constant need for being able to measure success criteria are fulfilled. Measurement is needed to support, among other issues, understanding, monitoring, control, management, evaluation, improvement and predictability of all aspects related to software development. In order for software engineering to become a true engineering discipline, measurement and quantitative assessment are crucial. The articles included in the special section are very good examples of how software engineering is moving in this direction.

Focuses on the agenda for the 1999 International Conference of Software Engineering in Los Angeles, California. Enhancement of the industrial presentation programs; List of participating research papers; Topics and writers for the research papers.

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.

Algebraic specifications have been used in the testing of object-oriented programs and received much attention since the 1990s. It is generally believed that class-level testing based on algebraic specifications involves two independent aspects: the testing of equivalent and nonequivalent ground terms. Researchers have cited intuitive examples to illustrate the philosophy that even if an implementation satisfies all the requirements specified by the equivalence of ground terms, it may still fail to satisfy some of the requirements specified by the nonequivalence of ground terms. Thus, both the testing of equivalent ground terms and the testing of nonequivalent ground terms have been considered as significant and cannot replace each other. In this paper, we present an innovative finding that, given any canonical specification of a class with proper imports, a complete implementation satisfies all the observationally equivalent ground terms if and only if it satisfies all the observationally nonequivalent ground terms. As a result, these two aspects of software testing cover each other and can therefore replace each other. These findings provide a deeper understanding of software testing based on algebraic specifications, rendering the theory more elegant and complete. We also highlight a couple of important practical implications of our theoretical results. [ABSTRACT FROM PUBLISHER]

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]

The interpretations of logical expressions found in most introductory textbooks are not suitable for use in software engineering applications because they do not deal with partial functions. More advanced papers and texts deal with partial functions in a variety of complex ways. This paper proposes a very simple change to the classic interpretation of predicate expressions, one that defines their value for all values of all variables, yet is almost identical to the standard definitions. It then illustrates the application of this interpretation in software documentation. [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]

Refactoring tools, common to many integrated development environments, can help programmers to restructure their code. These tools sometimes refuse to restructure the programmer's code, instead giving the programmer a textual error message that she must decode if she wishes to understand the reason for the tool's refusal and what corrective action to take. This paper describes a graphical alternative to textual error messages called Refactoring Annotations. It reports on two experiments, one using an integrated development environment and the other using paper mockups, that show that programmers can use Refactoring Annotations to quickly and accurately understand the cause of refactoring errors. [ABSTRACT FROM AUTHOR]

The note introduces a special section containing research papers on statistical and scientific database (SSDB) management, which appeared in the October 1985 issue of the periodical "IEEE Transactions on Software Engineering." The collection of papers reflect the diversity of approaches to the solutions of SSDB management including physical storage organization and the application of artificial intelligence expert system techniques. The first paper is an introduction to the key research issues of SSDB management. The second paper is on data compression. The third paper is on data management support of computational statistical data. The fourth paper is on query facilities for SSDB. The last paper is on applying the production systems techniques in artificial intelligence for performing estimation.

The benefits of the analysis of software faults and failures have been widely recognized. However, detailed studies based on empirical data are rare. In this paper, we analyze the fault and failure data from two large, real-world case studies. Specifically, we explore: 1) the localization of faults that lead to individual software failures and 2) the distribution of different types of software faults. Our results show that individual failures are often caused by multiple faults spread throughout the system. This observation is important since it does not support several heuristics and assumptions used in the past. In addition, it clearly indicates that finding and fixing faults that lead to such software failures in large, complex systems are often difficult and challenging tasks despite the advances in software development. Our results also show that requirement faults, coding faults, and data problems are the three most common types of software faults. Furthermore, these results show that contrary to the popular belief, a significant percentage of failures are linked to late life cycle activities. Another important aspect of our work is that we conduct intra- and interproject comparisons, as well as comparisons with the findings from related studies. The consistency of several main trends across software systems in this paper and several related research efforts suggests that these trends are likely to be intrinsic characteristics of software faults and failures rather than project specific. [ABSTRACT FROM AUTHOR]

The objective of this paper is to determine under what circumstances individual organizations would be able to rely on cross-company-based estimation models. We performed a systematic review of studies that compared predictions from cross company models with predictions from within-company models based on analysis of project data. Ten papers compared cross company and within-company estimation models; however, only seven presented independent results. Of those seven, three found that cross-company models were not significantly different from within-company models, and four found that cross-company models were significantly worse than within-company models. Experimental procedures used by the studies differed making it impossible to undertake formal meta-analysis of the results. The main trend distinguishing study results was that studies with small within-company data sets (i.e., < 20 projects) that used leave-one-out cross validation all found that the within-company model was significantly different (better) from the cross-company model. The results of this review are inconclusive. It is clear that some organizations would be ill-served by cross-company models whereas others would benefit. Further studies are needed, but they must be independent (i.e., based on different data bases or at least different single company data sets) and should address specific hypotheses concerning the conditions that would favor cross-company or within-company models. In addition, experimenters need to standardize their experimental procedures to enable formal meta-analysis, and recommendations are made in Section 3. [ABSTRACT FROM AUTHOR]

This article presents information about the selection of the four best papers submitted to the 27th International Conference on Software Engineering held on May 21, 2005. A summary for each paper is provided along with the author's name and the main topic of each paper. One paper deals with a new approach to software fault tolerance. Another paper discusses an environment for finding and visualizing examples of usage of an API. The third paper reports on a study to determine the limitations of tools used in computer maintenance tasks.

This paper presents a general approach for analysis and verification of authentication properties using the theory of Communicating Sequential Processes (CSP). The paper aims to develop a specific theory appropriate to the analysis of authentication protocols, built on top of the general CSP semantic framework. This approach aims to combine the ability to express such protocols in a natural and precise way with the ability to reason formally about the properties they exhibit. The theory is illustrated by an examination of the Needham-Schroeder Public-Key protocol. The protocol is first examined with respect to a single run and then more generally with respect to multiple concurrent runs. [ABSTRACT FROM AUTHOR]

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]

This paper describes an approach to software specification development with interpretation as applied to an information storage and retrieval system. Machine execution of software specifications is possible with both partial and complete specifications. A partial specification is interpreted using abstract execution. The Descartes specification language is utilized to describe a functional aspect of an existing information storage and retrieval system, namely, the MADAM (Multics Approach to Data Access and Management) system at the University of Southwestern Louisiana. Brief descriptions of both the Descartes language and the MADAM system precede the example specification. The paper concludes with a discussion of the expected results that this methodology could have on the pragmatic development and evolution of information systems. [ABSTRACT FROM AUTHOR]

The increasing cost of computer system failure has stimulated interest in improving software reliability. One way to do this is by adding redundant structural data to data structures. Such redundancy can be used to detect and correct (structural) errors in instances of a data structure. The intuitive approach of this paper, which makes heavy use of examples, is complemented by the more formal development of the companion paper. "Redundancy in Data Structures: Some Theoretical Results." [ABSTRACT FROM AUTHOR]

Recent advances in technology have made the construction of general-purpose systems out of many small independent microprocessors feasible. One of the issues concerning distributed systems is the question of appropriate language constructs for the handling of communication and synchronization. In his paper, "Communicating sequential processes," Hoare has suggested the use of the input and output constructs and Dijkstra's guarded commands to handle these two issues. This paper examines Hoare's concepts in greater detail by concentrating on the following two issues: 1) allowing both input and output commands to appear in guards, 2) simple abstract implementation of the input and output constructs. In the process of examining these two issues we develop a framework for the design of appropriate communication and synchronization facilities for distributed systems. [ABSTRACT FROM AUTHOR]

The Third International Conference on Data Engineering was held in Los Angeles, California on February 2 to 6, 1987. The conference was designed as an international forum for bringing together researchers, developers, managers, strategic planners and other users with an interest in the research, design and development of data engineering methodologies, strategies and systems. Its scope includes computer science, artificial intelligence, electrical engineering, and computer engineering. It featured papers from all major areas of data engineering, including database design and modeling, performance evaluation, algorithms, integrity, security, fault tolerance, query language, artificial intelligence approaches, knowledge bases, database machines, distributed databases and data engineering applications.

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.

Modern software systems are increasingly configurable. While this has many benefits, it also makes some software engineering tasks,such as software testing, much harder. This is because, in theory,unique errors could be hiding in any configuration, and, therefore,every configuration may need to undergo expensive testing. As this is generally infeasible, developers need cost-effective technique for selecting which specific configurations they will test. One popular selection approach is combinatorial interaction testing (CIT), where the developer selects a strength t and then computes a covering array (a set of configurations) in which all t-way combinations of configuration option settings appear at least once. In prior work, we demonstrated several limitations of the CIT approach. In particular, we found that a given system’s effective configuration space—the minimal set of configurations needed to achieve a specific goal—could comprise only a tiny subset of the system’s full configuration space. We also found that effective configuration space may not be well approximated by t-way covering arrays. Based on these insights we have developed an algorithm called interaction tree discovery (iTree). iTree is an iterative learning algorithm that efficiently searches for a small set of configurations that closely approximates a system’s effective configuration space. On each iteration iTree tests the system on a small sample of carefully chosen configurations, monitors the system’s behaviors, and then applies machine learning techniques to discover which combinations of option settings are potentially responsible for any newly observed behaviors. This information is used in the next iteration to pick a new sample of configurations that are likely to reveal further new behaviors. In prior work, we presented an initial version of iTree and performed an initial evaluation with promising results. This paper presents an improved iTree algorithm in greater detail. The key improvements are based on our use of composite proto-interactions—a construct that improves iTree’s ability to correctly learn key configuration option combinations, which in turn significantly improves iTree’s running time, without sacrificing effectiveness. Finally, the paper presents a detailed evaluation of the improved iTree algorithm by comparing the coverage it achieves versus that of covering arrays and randomly generated configuration sets, including a significantly expanded scalability evaluation with the \sim1M-LOC MySQL. Our results strongly suggest that the improved iTree algorithm is highly scalable and can identify a high-coverage test set of configurations more effectively than existing methods. [ABSTRACT FROM PUBLISHER]

Context: Variability (i.e., the ability of software systems or artifacts to be adjusted for different contexts) became a key property of many systems. Objective: We analyze existing research on variability in software systems. We investigate variability handling in major software engineering phases (e.g., requirements engineering, architecting). Method: We performed a systematic literature review. A manual search covered 13 premium software engineering journals and 18 premium conferences, resulting in 15,430 papers searched and 196 papers considered for analysis. To improve reliability and to increase reproducibility, we complemented the manual search with a targeted automated search. Results: Software quality attributes have not received much attention in the context of variability. Variability is studied in all software engineering phases, but testing is underrepresented. Data to motivate the applicability of current approaches are often insufficient; research designs are vaguely described. Conclusions: Based on our findings we propose dimensions of variability in software engineering. This empirically grounded classification provides a step towards a unifying, integrated perspective of variability in software systems, spanning across disparate or loosely coupled research themes in the software engineering community. Finally, we provide recommendations to bridge the gap between research and practice and point to opportunities for future research. [ABSTRACT FROM PUBLISHER]

In software testing, something which can verify the correctness of test case execution results is called an oracle. The oracle problem occurs when either an oracle does not exist, or exists but is too expensive to be used. Metamorphic testing is a testing approach which uses metamorphic relations, properties of the software under test represented in the form of relations among inputs and outputs of multiple executions, to help verify the correctness of a program. This paper presents new empirical evidence to support this approach, which has been used to alleviate the oracle problem in various applications and to enhance several software analysis and testing techniques. It has been observed that identification of a sufficient number of appropriate metamorphic relations for testing, even by inexperienced testers, was possible with a very small amount of training. Furthermore, the cost-effectiveness of the approach could be enhanced through the use of more diverse metamorphic relations. The empirical studies presented in this paper clearly show that a small number of diverse metamorphic relations, even those identified in an ad hoc manner, had a similar fault-detection capability to a test oracle, and could thus effectively help alleviate the oracle problem. [ABSTRACT FROM PUBLISHER]

The service-oriented paradigm offers support for engineering service-based systems (SBSs) based on service composition where existing services are composed to create new services. The selection of services with the aim to fulfil the quality constraints becomes critical and challenging to the success of SBSs, especially when the quality constraints are stringent. However, none of the existing approaches for quality-aware service composition has sufficiently considered the following two critical issues to increase the success rate of finding a solution: 1) the complementarities between services; and 2) the competition among service providers. This paper proposes a novel approach called combinatorial auction for service selection (CASS) to support effective and efficient service selection for SBSs based on combinatorial auction. In CASS, service providers can bid for combinations of services and apply discounts or premiums to their offers for the multi-dimensional quality of the services. Based on received bids, CASS attempts to find a solution that achieves the SBS owner's optimisation goal while fulfilling all quality constraints for the SBS. When a solution cannot be found based on current bids, the auction iterates so that service providers can improve their bids to increase their chances of winning. This paper systematically describes the auction process and the supporting mechanisms. Experimental results show that by exploiting the complementarities between services and the competition among service providers, CASS significantly outperforms existing quality-aware service selection approaches in finding optimal solutions and guaranteeing system optimality. Meanwhile, the duration and coordination overhead of CASS are kept at satisfactory levels in scenarios on different scales. [ABSTRACT FROM PUBLISHER]

Though very important in software engineering, linking artifacts of the same type (clone detection) or different types (traceability recovery) is extremely tedious, error-prone, and effort-intensive. Past research focused on supporting analysts with techniques based on Natural Language Processing (NLP) to identify candidate links. Because many NLP techniques exist and their performance varies according to context, it is crucial to define and use reliable evaluation procedures. The aim of this paper is to propose a set of seven principles for evaluating the performance of NLP techniques in identifying equivalent requirements. In this paper, we conjecture, and verify, that NLP techniques perform on a given dataset according to both ability and the odds of identifying equivalent requirements correctly. For instance, when the odds of identifying equivalent requirements are very high, then it is reasonable to expect that NLP techniques will result in good performance. Our key idea is to measure this random factor of the specific dataset(s) in use and then adjust the observed performance accordingly. To support the application of the principles we report their practical application to a case study that evaluates the performance of a large number of NLP techniques for identifying equivalent requirements in the context of an Italian company in the defense and aerospace domain. The current application context is the evaluation of NLP techniques to identify equivalent requirements. However, most of the proposed principles seem applicable to evaluating any estimation technique aimed at supporting a binary decision (e.g., equivalent/nonequivalent), with the estimate in the range [0,1] (e.g., the similarity provided by the NLP), when the dataset(s) is used as a benchmark (i.e., testbed), independently of the type of estimator (i.e., requirements text) and of the estimation method (e.g., NLP). [ABSTRACT FROM AUTHOR]