International Journal of Software Engineering and Knowledge Engineering

The major issues in designing Distributed Information Systems (DIS) include localization of control and data, inherent concurrency, intensive interactions among computation agents, history sensitivity, dynamic configuration and continuous system change and evolution. We propose a framework, called the G-Net model, for the specification, modeling and prototyping of DIS. The G-Net model not only provides a flexible notation to represent the executable specification of DIS through G-Net instantiation, but also offers a novel style of decentralized concurrent computation, allowing flexible inter-agent communication and interaction. A prototype of the G-Net framework has been implemented on workstations connected by a local network.

This paper presents an efficient algorithm to deal with inexact reasoning, where fuzzy production rules are used for knowledge representation and these rules are represented by an augmented fuzzy rule matrix F. The algorithm performs inexact reasoning via repeated transformations of augmented truth state vectors by the transitive closure Q of the augmented fuzzy rule matrix F. Given the truth values of some conditions, the algorithm can perform inexact reasoning to evaluate the truth values of other conditions automatically. The time complexity of the algorithm is 0(k(m+k)²), where m is the number of conditions and k is the number of compound conditions appearing in the antecedent portion of the fuzzy production rules.

In a software engineering environment, it is essential to describe the structures and behavior of different processes. Once the processes have been described, it would also be desirable to use the description for consistently controlling the execution of the processes. In this paper we describe an extension of the conventional object-oriented paradigm which provides an integrated process description/execution environment that allows a user to describe a process with multiple methodologies and to review a process from multiple views. Once a process has been described in detail, the environment can monitor the behavior of application processes, derive the inter-dependencies among different activities in a process, and check the consistency among the activities.

The goal of the Partial Metrics Project is the automatic acquisition of planning knowledge from target code modules in a program library. In the current prototype the system is given a target code module written in Ada as input, and the result is a sequence of generalized transformations that can be used to design a class of related modules. This is accomplished by embedding techniques from Artificial Intelligence into the traditional structure of a compiler. The compiler performs compilation in reverse, starting with detailed code and producing an abstract description of it. The principal task facing the compiler is to find a decomposition of the target code into a collection of syntactic components that are nearly decomposable. Here, nearly decomposable corresponds to the need for each code segment to be nearly independent syntactically from the others. The most independent segments are then the target of the code generalization process. This process can be described as a form of chunking and is implemented here in terms of explanation-based learning.

The problem of producing nearly decomposable code components becomes difficult when target code module is not well structured. The task facing users of the system is to be able to identify well-structured code modules from a library of modules that are suitable for input to the system. In this paper we describe the use of inductive learning techniques, namely variations on Quinlan's ID3 system that are capable of producing a decision tree that can be used to conceptually distinguish between well poorly structured code.

In order to accomplish that task a set of high-level concepts used by software engineers to characterize structurally understandable code were identified. Next, each of these concepts was operationalized in terms of code complexity metrics that can be easily calculated during the compilation process. These metrics are related to various aspects of the program structure including its coupling, cohesion, data structure, control structure, and documentation.

Each candidate module was then described in terms of a collection of such metrics. Using a training set of positive and negative examples of well-structured modules, each described in terms of the appointed metrics, a decision tree was produced that was used to recognize other well-structured modules in terms of their metric properties. This approach was applied to modules from existing software libraries in a variety of domains such as database, editor, graphic, window, data processing, FFT and computer vision software. The results achieved by the system were then benchmarked against the performance of experienced programmers in terms of recognizing well structured code. In a test case involving 120 modules, the system was able to discriminate between poor and well-structured code 99% of the time as compared to an 80% average for the 52 programmers sampled. The results suggest that such an inductive system can serve as a practical mechanism for effectively identifying reusable code modules in terms of their structural properties.

What affects software productivity and how do we improve it? This report examines the current state of the art in understanding and measuring software productivity. In turn, it describes a framework for understanding software productivity, identifies some fundamentals of measurement, surveys selected studies of software productivity, and identifies variables that affect software productivity. Then, a radical alternative to current approaches is suggested: to construct, evaluate, deploy, and evolve a knowledge-based "software productivity modeling and simulation system."