FW: CORE Review

Hi,

 

I send you my remarks about the last version of the CORE document I have
just read.

 

 

1)       Positive conditions syntax section

 

The core grammar is not easy to read. Here are some remarks that may
clarify it:

-          use longer abbreviations ( for example CONST or CONSTANT
instead of CON for example),

-          add a table listing  the symbols and the meaning as it is
provided later for the mapping on RuleML,

-          begin by the top node (CONDIT and  not Var)

-          add an UML schema showing the model. It gives a synthetic
view on the grammar.

 

The section about the free variables speaks about bodies and head of a
rule. Unfortunately, "rule bodies" means in the production rule world
the statement|action part of the rule. Even if the bodies|head terms are
natural in a logic rule context, the exercise of reversing the meaning
is possible although confusing. It does not simplify the understanding
for production rule system programmers. 

 

 

2)       Horn rule syntax section

 

Same remarks as for the positive condition grammar presentation:

-          add a table listing  the symbols and the meaning as it is
provided later for the mapping on RuleML,

-          begin by the top node CLAUSE,

-          use of body|head, 

 

The status of the slotted forms is not clear. Will it be limited to the
external calls section?

 

 

 

3)       Future extension to production rule

 

As a potential designer of a RIF-production rule translator, I wonder
how Core will be extended to easily represent production rules
expressions. I know that this task is dedicated to the second part of
RIF. However, it seems to me important to, even informally, check the
possibility of such extension from Core. Frankly, reading the document
does not indicate me some elements of design of future RIF-production
rule module. In fact, I list hereafter the common features I expect to
be translated into RIF expressions:

-          object model instruction (  set/get fields, method
invocation, classification...),

-          condition generator definition (in/from),

-          set conditions such as collector,

-          rule meta-information (priorities, name...),

-          build-in operator,

-          instructions of the right part (if, for, while, variable
declaration...). This right part is often composed of several
instructions.

-          Constant representation (numeric, String, boolean, date, XML
types...)

 

I would like to find a section in the Core given as an informal example
and proposing how to represent those features.

An important constraint of common production rules is the scalability.
One dimension of that problem is the number of rules. Is there any
scalability recommendation that may impact the XML format of the rules?

Another constraint is that production rules language be easily
understandable. Observing the distance between Horn rule syntax and
common production rules syntax, I wonder if the translation from RIF
expressions to production rules language will be easily performed!

 

 

Best regards. Philippe.