Search-based amorphous slicing

Amorphous slicing is an automated source code extraction technique with applications in many areas of software engineering, including comprehension, reuse, testing and reverse engineering. Algorithms for syntax-preserving slicing are well established, but amorphous slicing is harder because it requires arbitrary transformation; finding good general purpose amorphous slicing algorithms therefore remains as hard as general program transformation. In this paper we show how amorphous slices can be computed using search techniques. The paper presents results from a set of experiments designed to explore the application of genetic algorithms, hill climbing, random search and systematic search to a set of six subject programs. As a benchmark, the results are compared to those from an existing analytical algorithm for amorphous slicing, which was written specifically to perform well with the sorts of program under consideration. The results, while tentative at this stage, do give grounds for optimism. The search techniques proved able to reduce the size of the programs under consideration in all cases, sometimes equaling the performance of the specifically-tailored analytic algorithm. In one case, the search techniques performed better, highlighting a fault in the existing algorith

Design of Model For Restructure Transformation of Public Sector

Public sector such as Govt. University composed of many physical as well logical threads, which are very beneficial for public to provide services. Over times due to repeated modification of software modules, the structure of the system deteriorates and it become very complex to understand for further modification whenever requirement need to provide services to public, because it is universal truth after specific time period there is need of modification to fulfill the requirement for public. And if we repeat to modify the software module, then it is very complicated just like noodles in chowmin plate and program structure is twisted and tangled. Due to this program structure greatly decrease the scalability, reliability, efficiency, robustness and increased the complexity of software module. And it also increased the maintenance cost of software module, therefore repeated modification is not a good choice. Reengineering is good choice for this. Therefore, in this paper we will introduced a new methodology that is known as pattern based reengineer methodology, that is not only focus on only logical thread, but also focus on physical entities - reduce overall complexity. It is proved that the transformation does not alter the semantic of restructured program

AN EXECUTABLE SPECIFICATION FORMALISM REPRESENTING ABSTRACT DATA TYPES

It has been proved to be very useful and necessary to give formal specifications of software systems to be developed. The specifications should help to avoid the necessity of creating prototypes by offering direct executability. A useful specification language aiming the description of abstract data types - while maintaining abstractness - should also support the representation of states of objects, as well as support the transformation of declarative specifications into efficiently executable code. The present paper is intended to give an informal description of a specification language aimed to offer the features discussed above. Although the development of the language has mainly been motivated by the object-oriented language (OMOHUNDRO, 1993), it is intended to function as a specification formalism at a much broader field

Algebraic calculation of graph and sorting algorithms

We introduce operators and laws of an algebra of formal languages, a subalgebra of which corresponds to the algebra of (multiary) relations. This algebra is then used in the formal specification and derivation of some graph and sorting algorithms. This study is part of an attempt to single out a framework for program development at a very high level of discourse, close to informal reasoning but still with full formal precision

Refining ideal behaviours

This paper provides some mathematical properties of behaviours of systems, where the individual elements of a behaviour are modeled by ideals of a suitable partial order. It is well-known that the associated ideal completion provides a simple way of constructing algebraic cpos. An ideal can be viewed as a set of consistent finite or compact approximations of an object which itself may even be infinite. We introduce a special way of characterising behaviours through sets of relevant approximations

Genetic Improvement of Software: a Comprehensive Survey

Genetic improvement (GI) uses automated search to find improved versions of existing software. We present a comprehensive survey of this nascent field of research with a focus on the core papers in the area published between 1995 and 2015. We identified core publications including empirical studies, 96% of which use evolutionary algorithms (genetic programming in particular). Although we can trace the foundations of GI back to the origins of computer science itself, our analysis reveals a significant upsurge in activity since 2012. GI has resulted in dramatic performance improvements for a diverse set of properties such as execution time, energy and memory consumption, as well as results for fixing and extending existing system functionality. Moreover, we present examples of research work that lies on the boundary between GI and other areas, such as program transformation, approximate computing, and software repair, with the intention of encouraging further exchange of ideas between researchers in these fields

Synthesis of positive logic programs for checking a class of definitions with infinite quantification

We describe a method based on unfold/fold transformations that synthesizes positive logicprograms P(r)with the purpose of checking mechanically definitions of the form D(r) =∀X(r(X) ⇔QYR(X, Y))where ris the relation defined by the formula QYR(X, Y), Xis a set of variables to be instantiated at runtime by ground terms, QYis a set of quantifiedvariables on infinite domains (Qis the quantifier) and R(X, Y)a quantifier-free formulain the language of a first-order logic theory. This work constitutes a first step towards theconstruction of a new type of assertion checkers with the ability of handling restrictedforms of infinite quantification

Validation of Formal Specifications through Transformation and Animation

International audienceA significant impediment to the uptake of formal refinement-based methods among practitioners is the challenge of validating that the formal specifications of these methods capture the desired intents. Animation of specifications is widely recognized as an effective way of addressing such validation. However, animation tools are unable to directly execute (and thus animate) the typical uses of several of the specification constructs often found in ideal formal specifications. To address this problem we have developed transformation heuristics that, starting with an ideal formal specification, guide its conversion into an animatable form. We show several of these heuristics, and address the need to prove that the application of these transformations preserves the relevant behavior of the original specification. Portions of several case studies illustrate this approac