We propose HHWeb, an extension to LogicWeb with hereditary Harrop formulas. HHWeb extends the LogicWeb of Loke and Davison by allowing goals of the form ( x1... xn D) G (or equivalently x1... xn(D G)) where D is a web page and G is a goal. This goal is intended to be solved by instantiating x1,...,xn in D by new names and then solving the resulting goal. The existential quantifications at the head of web pages are particularly flexible in controlling the visibility of names. For example, they can provide scope to functions and constants as well as to predicates. In addition, they have such simple semantics that implementation becomes more efficient. Finally, they provide a client-side interface which is useful for customizing web pages.

One of the approaches to improve program understanding is to extract what kinds of design pattern are used in existing object-oriented software. This paper proposes a technique for efficiently and accurately detecting occurrences of design patterns included in source codes. We use both static and dynamic analyses to achieve the detection with high accuracy. Moreover, to reduce computation and maintenance costs, detection conditions are hierarchically specified based on Pree's meta patterns as common structures of design patterns. The usage of Prolog to represent the detection conditions enables us to easily add and modify them. Finally, we have implemented an automated tool as an Eclipse plug-in and conducted experiments with Java programs. The experimental results show the effectiveness of our approach.

In this paper we propose a new method for parallel execution of Prolog programs and present its implementation on a distributed memory parallel computer, Fujitsu AP1000. In our method a number of processes (named Prolog engines) explore different branches of a search tree (named tasks) in parallel, which is the same as OR-parallelism. Unlike OR-parallelism, the mapping between Prolog engines and tasks is statically determined like data parallelism. Each Prolog engine can decide which task is executed by the engine without communicating with the other engines. In many search problems, however, such static task mapping may cause imbalance on the processing time of each engine since the computational costs to explore branches may vary substantially. To cope with this issue, we devise a method to adjust the task imbalance by periodical exchanging how many tasks were processed for each engine. Also for reducing communication overhead in load balancing, we limit the scope of engines that exchange the load information each other. The effectiveness of our method is evaluated by measuring execution times for N Queens and the Traveling Salesman Problem on the AP1000. Using 512 processors, we obtained 355-fold speedup for N Queens and 343-fold speedup on the Traveling Salesman Problem.

In this paper we propose a method for generating Prolog program code and skeleton C code from a specification of requirements written in DFDs (Data Flow Diagram) and DD (Data Dictionary). This generation of code takes two transformation steps. The specification is transformed into a Prolog program and the transformed Prolog is used for generating skeleton C code so that the specification is directly expendable in the conventional programming environment. This work makes it possible to rapidly have a prototype by executing Prolog programs and remove the design stage from the software development life cycle. This has been implemented on UNIX workstation environment with a data flow diagram editor START system.

This paper proposes a protocol verification tool where protocols are described in an extended Petri net and Horn clauses. The extended net model contributes to reduce state space in verification with hierarchical description. The model also includes timed and colored net. Horn clause enables protocol designers to grasp a protocol by the declarative semantics. They can describe non critical but mandatory portion of a protocol like error processing or abortion with Horn clauses. Protocols are verified through simulation. Protocol verification includes two methods, all-in-one and hierarchical methods. By the all-in-one method all description is translated into Prolong clause and simulated exhaustively, whereas by the hierarchical verification, simulation begins with the lowest layer and deduces sufficient conditions that give liveness and safeness of the net model. Then the layer is replaced by a simpler net model that is incorporated into the higher layer. The scheme is applied to an illustrative example of the Alternating Bit protocol to discuss its effectiveness.

The paper proposes and reports on pototyping a work bench system for novice Prolog programmers which consists of a visually-structured interactive tracer and a prototype-based programming support. The tracer actually is a simulated interpreter in Prolog. It is interpreted by a Prolog interpreter being embedded with facilities interfacing programs in Prolog and the objects programmed in C. It displays, by way of these objects, the past, current and future goals, highlights variable sharing and value substitution, and marks the current goals and backtrack choice points. It is at user's will to let the tracer show and hide subgoals as well as to let it backtrack when it failed, step back for redoing or terminate tracing. The programming support module first provides the programmer with structural prototype patterns and the roles of the constituent functions. We developed a support system for the 2 types of recursive definitions. After having selected the prototype, the user is requested to specify the data types and the names of variables to be put in the arguments, which propagate through the structure. The support module then offers a menu of primitive or user-registered constituent functions as may be useful in processing and/or obtaining user-specified types of data. Thirdly the system lets the user express his/her intention by sample input-output data instances in his/her task goals. It makes the values propagate through the structures thus motivating the user to design the constituent functions. At the goal recursion point, the user is allowed to creep into examining the definitions of the reduced versions of the instances, helping the user find the condition with which the recursion terminates. Finally the module assists the user to convert the structural descriptions into Prolog programs.