Automated Software Engineering

Partial evaluation is an optimization technique traditionally used in compilation. We have adapted this technique to the understanding of scientific application programs during their maintenance. We have implemented a tool that analyzes Fortran 90 application programs and performs an interprocedural pointer analysis. This paper presents a dynamic semantics of Fortran 90 and manually derives a partial evaluator from this semantics. The tool implementing the specifications is also detailed. The partial evaluator has been implemented in a generic programming environment and a graphical interface has been developed to visualize the information computed during the partial evaluation (values of variables, already analyzed procedures, scope of variables, removed statements, etc.).

In the process of software development and maintenance, software debugging is an inevitable and time-consuming task. To accelerate software debugging, various approaches have been proposed to automate fault localization. Among them, testing-based fault-localization approaches are most promising, which use the execution information of many test cases to localize the faults. However, these existing testing-based fault-localization approaches ignore the similarity between test cases, which may harm the effectiveness of these approaches according to our previous research. Therefore, in this paper we propose a similarity-aware fault-localization approach, which takes each test case as a fuzzy set to deal with the similarity between test cases and calculates statements’ suspicions based on the probability theory. To investigate whether SAFL can address the similarity issue effectively, we manually injected redundant test cases in a test suite and performed an experimental study on the original test suite and the test suite with redundancy, respectively. The experimental results demonstrate that in our experiments SAFL is an effective fault-localization approach, whether there is manually injected redundancy in the test suite. To compare SAFL with most existing testing-based fault-localization approaches, we performed another experimental study on Siemens program suite, which is extensively used in the evaluation of many other testing-based fault-localization approaches. This experimental study confirms the effectiveness of SAFL. Based on the two experimental studies, it seems that in our experiments SAFL cannot only deal with test suites containing much redundancy effectively but also perform effectively for test suites without much redundancy.

The correct estimation of the software reliability level is fundamental to reduce efforts in the testing, maintenance and release activities. To help in this task, we find in the literature an increasing number of software reliability models (SRMs). However, none has proved to perform well considering different contexts. Due to this, the selection of the best model for a particular case is an important task. Most existing works on SRM selection need to test different models and decide based on how well the model fits the data and predicts the future events. Moreover, in general, they do not consider search-based models. Considering this fact, this paper introduces a Meta-learning approach for SRM selection. In such approach, some meta-features are used to indicate the best performing model. The approach is independent of the type of models to be selected, and can be used with different data mining algorithms. It includes the following activities: meta-knowledge extraction, meta-learning and classification. The activities meta-knowledge extraction and meta-learning are performed just once and generate a meta-classifier. Therefore, the meta-classifier is used to select the most adequate model for new projects (classification activity). The approach is evaluated in a set of experiments and the results do not show statistical difference between the Meta-learning approach and the choice of the best performing model. Otherwise, the results point out statistical difference between the Meta-learning approach and the choice of the worst performing model with a large stochastic difference according to the Vargha and Delaney Effect Size.

An amorphous slice of a program is constructed with respect to a set of variables. The amorphous slice is an executable program which preserves the behaviour of the original on the variables of interest. Unlike syntax-preserving slices, amorphous slices need not preserve a projection of the syntax of a program. This makes the task of amorphous slice construction harder, but it also often makes the result thinner and thereby preferable in applications where syntax preservation is unimportant. This paper describes an approach to the construction of amorphous slices which is based on the Abstract Syntax Tree of the program to be sliced, and does not require the construction of control flow graphs nor of program dependence graphs. The approach has some strengths and weaknesses which the paper discusses. The amorphous slicer, is part of the GUSTT slicing system, which includes syntax preserving static and conditioned slicers, a side effect removal transformation phase, slicing criterion guidance and for which much of the correctness proofs for transformation steps are mechanically verified. The system handles a subset of WSL, into which more general WSL constructs can be transformed. The paper focuses upon the way in which the GUSTT System uses dependence reduction transformation tactics. Such dependence reduction is at the heart of all approaches to amorphous slicing. The algorithms used are described and their performance is assessed with a simple empirical study of best and worst case execution times for an implementation built on top of the FermaT transformation system for maintenance and re-engineering.

Software defined network (SDN) has gained a great attention in academic field for its separation of the control plane and the data plain to get a programmable network. In the study, we propose an SDN architecture for a scenario of intelligent patent prior art search system. Different from the current mainstream patent retrieval system, where patent prior art search is executed by means of traditional keywords matches under a fixed network topology, our proposed patent prior art search system based on SDN architecture can provide systematic and security analysis of patent text when encountering big data flows of patent applications. We also propose a new Phrase-based patent text representation model (PPTR), where the whole patent text is represented as a Bag of Phrases and then embedded into vector for patent prior art search, which could maintain the integrity of semantic units of patent text. Our experiments show that the proposed PPTR model achieves the best performance compared with traditional approaches of patent prior art search, and it is also expected that SDN architecture is a promising platform framework for other patent mining tasks.

We report on a case study to assess the use of an advanced knowledge-based software design technique with programmers who have not participated in the technique's development. We use the KIDS approach to algorithm design to construct two global search algorithms that route baggage through a transportation net. Construction of the second algorithm involves extending the KIDS knowledge base. Experience with the case study leads us to integrate the approach with the spiral and prototyping models of software engineering, and to discuss ways to deal with incomplete design knowledge.

The field of knowledge-based software engineering has been undergoing a shift in emphasis from automatic programming to human augmentation and empowerment. In our research work, we support this shift with an approach that embedshuman-computer cooperative problem-solving tools intodomain-oriented, knowledge-based design environments. Domain orientation reduces the large conceptual distance between problem-domain semantics and software artifacts. Integrated environments support the coevolution of specification and construction while allowing designers to access relevant knowledge at each stage within the software development process. This paper argues thatdomain-oriented design environments (DODEs) are complementary to the approaches pursued withknowledge-based software assistant systems (KBSAs). The DODE extends the KBSA framework by emphasizing a human-centered and domain-oriented approach facilitating communication about evolving systems among all stakeholders. The paper discusses the major challenges for software systems, develops a conceptual framework to address these problems, illustrates DODE with two examples, and assesses the contributions of the KBSA and DODE approaches toward solving these problems.

Using cloud-based services can improve the performance, reliability, and scalability of a software application. However, transitioning an application to use cloud-based services is difficult, costly, and error-prone. The required re-engineering effort includes migrating to the cloud the functionality to be accessed as remote cloud-based services and re-targeting the client code accordingly. In addition, the client must be able to detect and handle the faults raised in the process of invoking the services. As a means of streamlining this transitioning, we developed a set of refactoring techniques—automated, IDE-assisted program transformations that eliminate the need to change programs by hand. In particular, we show how a programmer can extract services, add fault tolerance functionality, and adapt client code to invoke cloud services via refactorings integrated with a modern IDE. As a validation, we have applied our approach to automatically transform two third-party Java applications to use cloud-based services. We have also applied our approach to re-engineer a suite of services operated by General Electric to use cloud-based resources to better satisfy the GE business requirements.

We introduce in this paper an itemset mining approach to tackle the fault localization problem, which is one of the most difficult processes in software debugging. We formalize the problem of fault localization as finding the k best patterns satisfying a set of constraints modelling the most suspicious statements. We use a Constraint Programming (CP) approach to model and to solve our itemset based fault localization problem. Our approach consists of two steps: (i) mining top-k suspicious suites of statements; (ii) fault localization by processing top-k patterns. Experiments performed on standard benchmark programs show that our approach enables to propose a more precise localization than a standard approach.