International Journal of Software Engineering and Knowledge Engineering

Automatic programming is discussed in the context of software engineering. An approach to automatic programming is presented, which utilizes software engineering principles in the synthesis and maintenance of programs. As a simple demonstration, program-equivalent Turing machines are synthesized, encapsulated, reused, and maintained by genetic programming.

Turing machines are synthesized from input-output pairs for a variety of simple problems. When a problem is solved, the solution is encapsulated and becomes part of a software library. The genetic program uses the library to solve new problems by combining library components with program primitives to synthesize new programs. When a new problem is solved or a known problem is solved more efficiently, the genetic program maintains the library so as to keep it valid and efficient.

Efficiency is a problem in automatic programming, both in the programs produced and in the synthesis process itself. This paper presents a framework for using evolutionary mechanisms to guide program synthesis. A particular implementation of the framework, called Tierra, is described. Given a naive program and some limits on system resources, Tierra generates mutated programs and evolution proceeds by natural selection as the programs compete for Control Processing Unit (CPU) time and memory space. By applying the evolutionary mechanisms, Tierra has guided the automatic implementation of an efficient self-replicating program. The system is under continuing development; it is viewed more as a research tool than a prototype programming assistant; however, the performance of the system at present gives some hope for the ultimate feasibility of such systems.

In this paper we address the problem of software classification and, based on an algorithm for software classification through software repository clustering, we propose a method which performs automatic domain analysis on a given software collection. The described method relies on observations made after a tedious manual domain analysis is performed. Also, it requires a heuristic that can compute distances between two software components without any interference from the reuser.

Program understanding plays a very important role in the software engineering field as an essential part of the widely accepted reuse process. Unfortunately, the lack of general tools for this purpose often prevents users from effectively retrieving software modules for reuse. The primary difficulty is in determining which of the already-available modules performs the desired function. This paper explores the task of extracting functional knowledge from a program object (i.e., coded module) using an evolutionary-learning technique, cultural algorithms, to automatically learn classification rules for a reuse library. The modules are stored in a reuse library in the PM system using a faceted classification scheme. Therefore, the goal is to learn a set of rules to characterize the semantics of code modules based on their syntactic structure. The most difficult part of the process is to identify those parts of the program that provide specific evidence of the presence of a concept. Here, evolutionary-learning techniques are employed to interactively identify lines in a module that are "believed" to provide evidence for the presence of a facet value (concept) in the code by a user. A prototype is used to learn concepts relating to the "list" and "stack" programming concepts.

In this paper, we present a framework for maintainable software design, based on a multilevel understanding of software function. This framework is the novel functional representation ZD, in which domain concepts (e.g., employee records) as well as computational concepts (e.g., stacks and queues) are represented in a reusable manner. We use ZD to support the construction of a library of reusable components for novel configurations. In order to achieve this, we provide mechanisms for supporting flexible configurations, address problems of determining the correctness of a combination of library components, and consider the computational complexity of finding combinations. These problems all stem from problems of interactions between components. Therefore, the structure of ZD is focused on representing and handling these interactions. We show how the approach based on ZD resolves certain well-known problems faced by other library-based component reuse architectures.

Transformation systems allow us to support developments leading from an initial specification to a final program in a totally formal way. Transformations use valid properties of input objects to produce new equivalent ones. Most transformations use functional properties to increase the efficiency of programs. In doing so, they affect nonfunctional properties, which are usually not formally expressed. The problem we address is to recognize situations in which transformations can be achieved on the basis of the evaluation of a defined, nonfunctional property, and the aim of the present paper is to relate program transformations to nonfunctional properties evaluations. Indeed, a particular transformation tactic can be applied when a given property does not hold. The DEVA language has been used as a support of our experiments in the development of programs.

This survey reviews four classes of reengineering of software systems: code restructuring and translation of code into a new language, design recovery for corrective maintenance, design recovery for software enhancement, and software reengineering as part of radical business process reengineering. Special attention is given to the reengineering of data bases and user interfaces. We also consider concurrent software engineering, its place in the software reengineering process, and groupware in support of this process.