International Journal of Software Engineering and Knowledge Engineering

This paper presents how we developed a tool for generating data access programs from PCTE data schemas. We propose first an extended PCTE data model which allows constraints to be explicitly described between values of the data types. Our program generator analyzes this data model, which we call the constrained SDS, and generates a C++ library. A class of C++ is generated from each object type defined in the constrained SDS, and a set of member functions is generated from attribute types, link-types, and constraints defined in the SDS. The library provides convenient ways for accessing data which are stored according to the given constrained SDS. An example shows the benefits of using the program generator for tool development in PCTE.

Software engineering is particularly concerned with the construction of large systems. Existing software engineering tools tend to be adequate for medium-sized systems, but not as useful for large and very large systems. This paper presents a model viewing system as the basis for graph-based CASE tools which overcomes this lack of scalability. With existing commercial tools the number of user steps to browse or edit a model increases with the size of the model. With the approach of this paper, the number of steps remains constant regardless of the model size. In fact, only one step is required for operations such as adding a flow between two processes anywhere in the model, or moving a submodel to a new parent. This paper outlines the approach with a structured analysis example, provides a formal description of the model viewing system, and discusses some limitations.

Although many CASE tools for object-oriented methods (OO CASE tools) have been proposed, few, if any, can verify that the constructed analysis and design models actually match the requirements of the system being developed. In order to realize this kind of verification, we propose a software development method amalgamating OO CASE tools and algebraic specification techniques. We are developing an experimental system named COOAD (CASE tool for Object-Oriented Analysis and Design) in order to examine the effectiveness of our proposition. COOAD supports object-oriented analysis and design, verification of the analysis and design, and generation of code. In this paper, we propose the software development method, introduce COOAD, and illustrate the facilities of COOAD with an example.

In object-oriented software development, it is generally accepted that inheritance should be used just to model a generalization/specialization relationship (i.e., an IS-A). This analysis/design guideline is too permissive. Some researchers thus advocate that a subclass should inherit the full behavior of its superclass. Behavior inheritance, however, is far too restricted. In this paper, we establish a formal model that can clearly differentiate IS-A from behavior inheritance. Under this model, IS-A and behavior inheritance can be decomposed into more fundamental concepts: subset and abstraction/concretization. Also, we are able to develop a set of refined guidelines regarding the use of inheritance.

Areas of computer application are being broadened rapidly due to the rapid improvement of the performance of computer hardware. This results in increased demands for computer applications that are large and have complex temporal characteristics.

This paper introduces a real-time systems anlaysis method named PARTS. PARTS supports analyses from two viewpoints: external viewpoint, a view of the system from the user's perspective, and internal viewpoint, a view from the developer's perspective. These viewpoints are specified using formal languages, which are Real-Time Events Trace (RTET) for the external viewpoint, and Time Enriched Statechart (TES) and PARTS Data Flow Diagram (PDFD) for the internal viewpoint. All PARTS languages are based on the Metric Temporal Logic (MTL), and consistency of the specifications made from the two different viewpoints are analyzed based on the same MTL formalism.

A generic architecture for the development and application of software conversion tools exposes the requirements set for appropriate enabling technologies. Extrapolation of this set beyond its satisfaction by existing proprietary technology then exposes the opportunity/need for open interfaces between separate components providing orthogonal dimensions of the overall functionality. Some novel aspects of the solutions considered include retrofitting persistence to an open compiler-compiler, and using the Unix file system as a persistent object store, while in the background the advent of standard interfaces to persistence technology suggests that the overall goal is feasible.

The ten-year gap between the emergence of Software Engineering (SE) and Knowledge Engineering (KE) has led to the two disciplines developing along different methodological lines. In this paper, we point out that, after having passed through a period during which they ignored each other, followed by a competitive phase, the two disciplines have now reached a meeting point. We see the need for a life-cycle model for systems that integrate traditional and knowledge-based software. Besides, software development in the 21st century will entail open requirements and technological tools that will evolve during the life-cycle. Finally, the paper discusses a proposal for a conical-type spiral life-cycle model that seeks to meet all those needs.

A logic database has two components. One comprises the base knowledge, represented explicitly, called the extensional base. The other stores more general knowledge in the form of derivation rules, and is called the intensional base. One may calculate derived facts in advance and store (or materialize) them. Thus, the response time can be expected to speed up.

In this paper, we study a new evaluation technique for incrementally maintaining derived facts whenever updates occur on base facts. Our method is based on the seminaive evaluation so it is easy to implement; it is set-oriented, multiple updates may be dealt within a single manipulation; and insertion and deletion are treated uniformly. The method is evaluated analytically as well as experimentally.

We indicate the potential application of our incremental method to a computational linguistic problem, i.e., parsing incomplete sentences.

Related work in both areas of logic databases and computational linguistics are discussed.