Document Identification by Shallow Semantic Analysis

Reliability problems in software engineering — a review: Downs, TComput. Syst. Sci. Eng. Vol 2 No 3 (July 1987) pp 131–147

<strong>Background: </strong>Statistical concepts and techniques are often applied incorrectly, even in mature disciplines such as medicine or psychology. Surprisingly, there are very few works that study statistical problems in software engineering (SE).<strong>Aim: </strong>Assess the existence of statistical errors in SE experiments.<strong>Method: </strong>Compile the most common statistical errors in experimental disciplines. Survey experiments published in ICSE to assess whether errors occur in high quality SE publications.<strong>Results:</strong> The same errors as identified in others disciplines were found in ICSE experiments, where 30% of the reviewed papers included several error types such as: a) missing statistical hypotheses, b) missing sample size calculation, c) failure to assess statistical test assumptions, and d) uncorrected multiple testing. This rather large error rate is greater for research papers where experiments are confined to the validation section. The origin of the errors can be traced back to: a) researchers not having sufficient statistical training, and, b) a profusion of exploratory research.<strong>Conclusions:</strong> This paper provides preliminary evidence that SE research suffers from the same statistical problems as other experimental disciplines. However, the SE community appears to be unaware of any shortcomings in its experiments, whereas other disciplines work hard to avoid these threats. Further research is necessary to find the underlying causes and set up corrective measures, but there are some potentially effective actions and are a priori easy to implement: a) improve the statistical training of SE researchers, and b) enforce quality assessment and reporting guidelines in SE publications.

An in-depth review of key techniques in software error detection Software error detection is one of the most challenging problems in software engineering. Now, you can learn how to make the most of software testing by selecting test cases to maximize the probability of revealing latent errors. Software Error Detection through Testing and Analysis begins with a thorough discussion of test-case selection and a review of the concepts, notations, and principles used in the book. Next, it covers: Code-based test-case selection methods Specification-based test-case selection methods Additional advanced topics in testing Analysis of symbolic trace Static analysis Program instrumentation Each chapter begins with a clear introduction and ends with exercises for readers to test their understanding of the material. Plus, appendices provide a logico-mathematical background, glossary, and questions for self-assessment. Assuming a basic background in software quality assurance and an ability to write nontrivial programs, the book is free of programming languages and paradigms used to construct the program under test. Software Error Detection through Testing and Analysis is suitable as a professional reference for software testing specialists, software engineers, software developers, and software programmers. It is also appropriate as a textbook for software engineering, software testing, and software quality assurance courses at the advanced undergraduate and graduate levels.

Many software engineering tasks can potentially be automated using search heuristics. However, much work is needed in designing and evaluating search heuristics before this approach can be routinely applied to a software engineering problem. Experimental methodology should be complemented with theoretical analysis to achieve this goal. Recently, there have been significant theoretical advances in the runtime analysis of evolutionary algorithms (EAs) and other search heuristics in other problem domains. We suggest that these methods could be transferred and adapted to gain insight into the behaviour of search heuristics on software engineering problems while automating software engineering.

Search-based software engineering (SBSE) consists of the application of metaheuristic search techniques—such as genetic algorithms, simulated annealing, hill climbing, and tabu search—to software engineering problems. This idea is based on the observation that some software engineering activities can be thought of as optimization problems, and on the fact that techniques providing exact solutions are, very often, unable to adequately scale to large, real-world software engineering problems. Define fitness functions to guide an automated search for solutions, rather than attempting to construct solutions from scratch by hand. SBSE moves the engineer up the abstraction chain, from the tedious and expensive role of detailed solution construction, to the potentially more productive and more cost-effective area of fitness function design. This approach has been repeatedly demonstrated to have successful applications across the software engineering life cycle from requirements and project planning to maintenance and testing. This special issue focuses on applications of search SBSE to the maintenance phase of the life cycle. After software testing 2, software maintenance is the most widely studied application area for SBSE research. Work on SBSE applications to problems in software maintenance can be traced back to the pioneering work of the Mancoridis et al. 3, which led to the development of the Bunch tool for software re-modularization 4. In the past five years there has been a significant increase in SBSE applications to software maintenance and evolution. Search-based techniques have been applied to post-development code improvement problems, such as object-oriented refactoring 5, 6, and imperative language slicing and transformation 7. Other applications are related to software engineering economics and project management problems, such as release planning 8-12, effort, and cost estimation 13-16, and project staffing and planning 17-20. Last, but not the least, SBSE has been applied to deal with service-oriented architectures, for example for services QoS-aware composition 21, service-level agreement negotiation 22, and testing 23. A complete overview of SBSE with a discussion of future research trends can be found in the recent International Conference on Software Engineering (ICSE) ‘Future of Software Engineering’ paper 24. This issue of the Journal of Software Maintenance and Evolution: Research and Practice features three outstanding papers, dealing with different aspects of software maintenance and evolution: release planning and staffing, re-factoring, and component substitution. The paper ‘Optimized Staffing for Product Releases—Focused Search and its Application at Chartwell Technologies’ by Puneet Kapur, An Ngo-The, Günther Ruhe, and Andrew Smith presents an approach for optimizing the staffing for product releases. The problem they solve can be viewed as part of the more general release planning problem, which assigns features to releases such that technical, resource, risk, and budget constraints are met. In particular, the genetic search-based approach the authors propose aims at assigning human resources to software development tasks, taking them from a pool of developers having different levels of skills. The applicability of the proposed approach is demonstrated with an industrial case study. The paper ‘Search-Based Refactoring: an Empirical Study’ by Mark O'Keffe and Mel Ó Cinnéide presents an approach to automatically re-factor, using search-based techniques, object-oriented systems that undergo repeated addition of functionality. Such addition can, very often, deteriorate the quality of the system's underlying design. Their re-factoring is guided by the QMOOD quality model 25, and the paper compares different optimization techniques, such as Genetic Algorithms, Simulated Annealing, and Multiple Ascent Hill-Climbing. The results of experiments carried out on five software systems suggest that the latter technique outperforms the others. The paper ‘Search-based Many-to-one Component Substitution’ by Nicolas Desnos, Marianne Huchard, Guy Tremblay, Christelle Urtado, and Sylvain Vauttier presents a search-based approach that allows the replacement of an obsolete component with a composition of multiple components. When a component becomes obsolete, the approach searches for a minimal assembly of other components, exposing their functionality by means of ports that preserves the behavior of the original component. The proposed approach has been evaluated on a set of randomly generated components. We hope that readers will enjoy this special issue and find the selected papers insightful and inspiring. We would like to thank all the authors who presented papers for this special issue: there were many good quality papers, but unfortunately we could accept only three of them. Last, but not the least, we would like to thank the reviewers who provided timely, detailed and constructive feedbacks to the authors. Without their precious help this special issue would not have been possible.

Semantic relations are an important element in the construction of ontologies and models of problem domains. Nevertheless, they remain fuzzy or under-specified. This is a pervasive problem in software engineering and artificial intelligence. Thus, we find semantic links that can have multiple interpretations in wide-coverage ontologies, semantic data models with abstractions that are not enough to capture the relation richness of problem domains, and improperly structured taxonomies. However, if relations are provided with precise semantics, some of these problems can be avoided, and meaningful operations can be performed on them. In this paper we present some insightful issues about the modeling, representation and usage of relations including the available taxonomy structuring methodologies as well as the initiatives aiming to provide relations with precise semantics. Moreover, we explain and propose the control of relations as a key issue for the coherent construction of ontologies.

Systematic formulation of software process models (SPM) is currently a challenging problem in software engineering. We present an approach to define such models that encourages: reuse of both elements and models; modularity and incrementality in model construction; simplicity and naturality of the resulting model; and a high degree of concurrence in their enaction. We focus on model definition, distinguishing as usual its static and dynamic parts. We define the static part by means of formally defined hierarchies introducing the categories of elements that take part in SPM definition. Such hierarchies may be constructed and enlarged according to the requirements of any specific SPM. We present as an example a hierarchy for component programming that takes into account non-functional aspects of software (efficiency, etc.). The dynamic part of the SPM is defined by means of precedence relationships between tasks that take part in the model. These precedence relationships are represented with precedence graphs. Development strategies are defined by encapsulating new precedence relationships in modules, that can be combined and reused.

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

Finding a useful abstract representation is fundamental to solving many difficult problems in software engineering. In order to better understand how representations are actually used in key collaborative software engineering tasks, this empirical study examined all of the spoken representations of software behavior in 9 domain analysis sessions. It found that about 70% of them were metaphorical, representing system behavior as physical movement of objects, as perceptual processes, or in anthropomorphic terms ascribing beliefs and desires to the system. The pattern of use of these representations indicates 1) that they were not merely temporary placeholders, but rather their use persisted even when a specialized and more formal vocabulary had been developed, and 2) the metaphoric descriptions appear to reflect actual use of metaphor, rather than just a choice of vocabulary. The use of metaphor is explained in terms of how well they serve human cognitive abilities and collaborative needs. The predominance of metaphorical representations in synchronous collaborative sessions raises important issues about the possible misleading effects of metaphorical thinking. It also raises questions about the compatibility of the spoken representations with other representations (e.g., diagrams, specification languages) that trigger, and capture the results of, the verbal collaborative work.

: In keeping with the primary objective of the grant the HUFAST research team designed and developed tools to assist in the development of component-based, fault-tolerant C4I systems. During the first two years of this effort the HUFAST research program focused on fault-tolerant issues involving C4I systems in distributed environments. The work researched fundamental problems in software engineering with special emphasis on those problems most common to avionics. This period provided the basis for the middle two years where the research emphasized more technical results. Further these middle two years allowed us to apply our earlier results and direct our efforts more towards issues of fault-tolerance in targeted heterogeneous applications. The avoidance of single points of failure in distributed, component-based systems was emphasized. The primary purpose of our research was realized during the latter two years of the project with the creation of a Software Development Kit (SDK) comprised of methods and tools to assist the developers of fault-tolerant. component-based software for avionics and aerospace.

Parameterized matching on non-linear structures

A major problem in software engineering is assuring the correctness of a distributed system. A certifying distributed algorithm (CDA) computes for its input-output pair (i, o) an additional witness w – a formal argument for the correctness of (i, o). Each CDA features a witness predicate such that if the witness predicate holds for a triple (i, o, w), the input-output pair (i, o) is correct. An accompanying checker algorithm decides the witness predicate. Consequently, a user of a CDA does not have to trust the CDA but its checker algorithm. Usually, a checker is simpler and its verification is feasible. To sum up, the idea of a CDA is to adapt the underlying algorithm of a program at design-time such that it verifies its own output at runtime. While certifying sequential algorithms are well-established, there are open questions on how to apply certification to distributed algorithms. In this paper, we discuss distributed checking of a distributed witness; one challenge is that all parts of a distributed witness have to be consistent with each other. Furthermore, we present a method for formal instance verification (i.e. obtaining a machine-checked proof that a particular input-output pair is correct), and implement the method in a framework for the theorem prover Coq.

Several evolutions in software engineering (SE) relate to the development of a reliable communication process among the project stakeholders. The models resulting from these improvements are the key instruments of communication in SE. There are studies that relate several problems in SE to user-engineers interactions during the modeling process. In addition to the usual challenges related to the technological issues of software modeling, new problems have appeared due to the presence of a multinational workforce. Specifically, people with distinct cultural identities must work together and, independently from their personal values and beliefs, they must develop common objectives. Consequently, this paper argues that the personality and cultural identity of project team members might be unconsciously affecting the SE process in a much greater way than is currently believed. Moreover, a research framework for investigating the influence of individual identities in the modelling techniques can present new perspectives for improving SE outcomes.

There has been a long history of applying AI technologies to address software engineering problems especially on tool automation. On the other hand, given the increasing importance and popularity of AI software, recent research efforts have been on exploring software engineering solutions to improve the productivity of developing AI software and the dependability of AI software. The emerging field of intelligent software engineering is to focus on two aspects: (1) instilling intelligence in solutions for software engineering problems; (2) providing software engineering solutions for intelligent software. This extended abstract shares perspectives on these two aspects of intelligent software engineering.

Teaching software engineering (SE) in our universities and colleges is crucial as a means to help offset the software crisis. This paper describes an evolutionary approach used at one university to address the problems of teaching software engineering. Issues of difficulty in teaching software engineering, the evolution of software engineering techniques and our specific evolutionary approaches to teaching software engineering are presented. The nature of our courses, projects and laboratories in the curriculum is examined. Suggestions are presented on enhancements to existing approaches to software engineering education techniques, with an emphasis on guidelines for projects.