Rule-based systems (RBS) play an important role in knowledge engineering and software engineering, e.g. with the business rules approach [1]. However, practical design of rules is a challenging task. It requires both ecient knowledge representation methods for rule bases, as well as practical design tools that support them. The Semantic Knowledge Engineering (SKE) [2] addresses these problems, by providing the XTT2 [3] and ARD+ [4] representation methods, and a dedicated design framework HaDEs, previously presented at KESE [5].
However, HaDEs turned out to be hard to use for knowledge engineers not familiar with SKE as well as for software engineers. This gave the motivation to develop a new front end to HaDEs, based on the popular Eclipse IDE. In this paper we present this new tool called HaDEsclipse [6]. First, we shortly discuss the SKE design process and how it is supported by HaDEs. Then we present the architecture and selected aspects of implementation of HaDEsclipse.
Our research concerns the representation and formal verication of RBS. An important result of our research is the SKE (Semantic Knowledge Engineering) [2] The paper is supported by the AGH UST Grant 15.11.120.361. methodology, which derives from the HeKatE (Hybrid Knowledge Engineering) research project [7]. It aims at providing an integrated process for design, implementation, and analysis of the RBS supported by HaDEs (HeKatE Design Environment) framework.
The main features of this methodology are:
1. Visual rule representation. The provided XTT2 [3] rule representation method that visualizes the rule base in the form of interconnected decision tables, which makes the design more transparent.
2. Supported rule modeling. The HaDEs framework provides a set of dedicated tools, which facilitate the design process.
3. Easy rule maintenance. The HaDEs-based design process consists of three stages. The transitions between stages are formally dened and automatically performed. The modication made in one stage can be automatically propagated into the following stages. 4. One rule type. As opposed to Business Rules, SKE provides only one type of rule production rule. However, the methodology provides dierent inference strategies that correspond to dierent types of Business Rules, e.g. derivation rule type corresponds to backward chaining inference mode. 5. Formal rule description and verication. The provided formal rule language based on the ALSV(FD) (Attributive Logic with Set of Values over Finite Domains) logic [7] allows for formalized representation and verication of rules. Moreover, the semantics of rules is precisely dened.
The SKE approach can be applied to a wide range of intelligent systems. In this context, two main areas have been identied in the project: control systems, in the eld of intelligent control, and Business Rules [1] and Business Intelligence systems, in the eld of software engineering. The HaDEs framework aims at supporting the SKE approach. In this approach, the application logic is expressed using forward-chaining decision rules. They form an intelligent rule-based controller or simply a business logic core. The logic controller is decomposed into multiple modules represented by decision tables. HaDEs supports a complete hierarchical design process for the creation of knowledge bases. The whole process consists of three stages: conceptual, logical and physical design and is supported by a number of tools providing the visual design and automated implementation 1 .
The conceptual design is the rst stage of the process. During this step, the ARD+ (Attribute Relationships Diagrams) method is used. The principal idea for this stage is to build a graph dening functional dependencies between attributes on which the rules are built. This stage is supported by two visual tools: VARDA (Visual ARD+ Rapid Development Alloy), and HQEd.
The logical design is the second stage of the process. During this stage, rules are designed using the visual XTT2 (Extended Tabular Trees version 2 ) [3] method. This phase can be performed as the rst one in the design or as the second one, when the input is provided from the conceptual design. It is supported by the dedicated editor HQEd (HeKatE Qt Editor). HQEd supports the HML format, which allows for importing models generated by VARDA, as well as for saving and loading the state of the design. Having a complete XTT2-based model the physical implementation can be generated automatically. In this stage, a logical model is transformed into an algebraic presentation syntax called HMR2 (HeKatE Meta Representation).
HMR is a textual representation of the XTT2 logic. It is a human readable form, as opposed to the machine readable HML format. The HMR representation can be directly executed by the dedicated inference engine tool, called HeaRT3 (HeKatE Run Time) [8]. The HeaRT engine has communication and integration facilities. It supports Java integration based on callback mechanism and Prolog JPL library, called JHeroic.
HaDEs proved to be an ecient framework for designing rule bases within the SKE approach. However, its main limitation is that it is a set of loosely connected tools. Moreover, these tools have custom GUIs, which is problematic for engineers not familiar with SKE. This gave motivation for the development of a new platform, providing a more user friendly front end to HaDEs.
A decision was made to use the popular Eclipse IDE, which is a widely used tool in the software engineering community. Using it a new integrating front end to HaDEs was developed [6]. HaDEsclipse was implemented as a plugin for Eclipse. It integrates modules for conceptual prototyping of rule bases, and a visual editor for logical design of extended decision tables grouping rules. It also allows for generating an executable form of the system, that can be later executed by an inference engine. Within this plugin, one can manage the whole SKE design process described in the previous section.
The main functional requirements of HaDEsclipse are aimed at integrating the existing components of HaDEs using Eclipse: The tool was implemented in Java as a plugin for Eclipse. All of the functional requirements where met. Five modules of HaDEsclipse successfully support the design with SKE. Thanks to HaDEsclipse the models created in the subsequent design phases are easily interchanged between the HaDEs tools. Moreover, the tool allows to run and verify rule models in HeaRT. For the visual design of the XTT2 tables HQEd is used, but les produced with it are exchanged with other tools transparently for the user.
An example session with the tool is presented in Figures 2 and 3. In the rst gure the conceptual design with ARD+ is presented. The conceptual model of the rule base is described using a set of attributes and dependencies between them. The HML le contains prototypes of decision tables holding the conditional and decision attributes. In the second gure the HMR editing process is presented. The plugin supports both syntax highlighting and hinting, as well as a structured XML editor in the case of ARD+. Schemas (headers) of the tables are dened base on the HML description. In given tables rules are dened using the xrule construct. In the paper the HaDEsclipse tool was presented. It is an integrating front-end for the HaDEs framework, which supports the knowledge engineering process in the SKE approach [2]. The new tool makes HaDEs more accessible and useful for software engineers.
Our future works include further integration of HaDEsclipse with other tools we developed. This includes design tools for business processes, and integration with business process engines. Finally, recent results include an Eclipse-based tool for generating test cases for unit testing based on a rule-based specication. This framework will be integrated with HaDEsclipse, bringing more practical benets from the area of knowledge engineering to software engineers [9].