Ernest, Doug, glad to have your perspective. Gave me some insight.
However, is there any efficient way to connect the ontology created using protege/jess to a C++ program efficiently. I want to create an intelligent database for my C++ program which infer information from raw data.
Kindly Advice.
Thank you.
John Felix C
On 6/26/06, Doug Metzler <[EMAIL PROTECTED]
> wrote:
Hello,
Some comments and questions:
I'm new to Jess but familiar with Clips and its predecessors.
One issue that I noticed with Jess is that it apparently has only
depth first and breadth first conflict resolution. I found that
odd since it has been my impression that the vast majority of programs
written in OPS, Clips, etc. over the years have used MEA or LEX.
Although the manual says that it is easy to write your own CR code
I haven't had the opportunity to try that (since I'm still waiting for an
academic license :). Moreover, although I have written naive (Reteless)
implementations of production systems in Lisp/CLOS (including
various CR strategies), it doesn't strike me at all easy to implement
the OPS/Clips version of recency/specificity based strategies since
they depend on the details of the implementations of the KB and the
Rete, and I don't think I've ever seen that exactly spelled out in the
documentation of Clips or its predecessors. It is clear how recency and
specificity are combined in the abstract, but as I recall, the unit
regarding recency is the time tag of the matched KB object, while the
unit regarding specificity is something closer to the tests in the LHS
patterns/in the Rete, and yet the LEX and MEA strategies are described as
if the units where the same. Do most people using Jess write their own CR
strategies or does the Jess community find recency/specificity (and goal
based) strategies unnecessary? If the latter I'm curious why.
BTW, regarding the thread on documentation, the inherent self-documenting
nature of rule based systems (when as Ernest pointed out, programmers make
use of the documentation string) is all the stronger when the system is
goal based, which takes me back to the question on MEA.....
Unrelated question: I have begun to use Jess with JessTab and Protege.
I would prefer to use an interface with movable windows that are
simulataneously visible, rather than the alternative tab views of JessTab.
Anybody have a suggestion on what the easiest way to implement that would
be?
Thanks,
Doug Metzler
University of Pittsburgh
On Fri, 23 Jun 2006, friedman_hill ernest j wrote:
> I think John wrote:
>
> I hesitate to get involved in this discussion, but perhaps by
> supplying some of the missing information early on, I can avoid
> turmoil later.
>
>>
>> Well...let me start will the fundamentals of rule-based programming in both
>> Jess and CLIPS. Rule-based programming resembles event-based programming
>> (like exceptions in Java). If we can program rules in Java or C++, then what
>> is the need for Jess and Protege. What role does these tools play?
>
> First and foremost, the right tool for any job is the one that lets
> you solve the problem at hand, such that the result is fast enough,
> scales well enough, and such that the resulting code can be
> maintained. No one tool is right for every job.
>
>>
>> Today, I re-programmed my entire ontology in VC++ using MFC(event-based).
>> The result is faster and highly portable ontology.
>
> I am amused to hear VC++ and MFC referred to as being more portable
> than Java. But in any case, if what you've written solves whatever
> problem you're solving easily enough and well enough, then indeed,
> you've found the right tool for the job. No arguments there.
>
> Rule engines are used by many companies for a number of reasons, but
> among them are modularity (the individual rules are independent),
> scalability (continues to work well as the number of rules and working
> memory elements increases), liveness (the ability to modify a running
> rulebase,) performance, and maintainability (due largely to the
> modularity.) If you read up on the Rete algorithm, as described in the
> Jess manual and elsewhere, you'll get an idea of the kind of
> siutuation in which a good rule engine can perform much better than
> the sort of code you've written.
>
>> OK ....let me compare CLIPS and Jess. Both have the same syntax...CLIPS can
>> be portable to almost any language. Also, since it is built in C, the
>> run-time is extremely fast comparing Jess. On the other hand, Jess depends
>> on Java and Java programming alone for external interface.
>
> Jess was written to use largely the same syntax as CLIPS to make
> transitioning from CLIPS to Jess easier. But Jess was (as should go
> without saying) intended to improve upon CLIPS, and many people feel
> that it has succeeded in that regard.
>
> What I'm hearing from you is that you're not a Java person, and that's
> really fine. The world of programming still divides fairly neatly into
> Java and non-Java camps, into Microsoft and non-Microsoft camps. This
> is not the place to have those kinds of discussions. Suffice to say
> that for many programming shops, being Java-based is an advantage
> rather than a liability.
>
> The claims about C/C++ being intrisically faster than Java are just FUD;
> there are many benchmarks available on the Web showing that this
> simply isn't true, and hasn't been since Java's earliest days. One
> thing about Java that *is* slow is program startup, so if you're
> writing toy programs that run for only a second, then Java is indeed
> going to seem slower. For substantial programs, or even small programs
> that run in a persistent application server, then this startup issue
> isn't there. Of course, most code being written today falls into this
> last category.
>
> But in fact, the truth is that Jess is often much faster than CLIPS
> for nontrivial programs due to the advanced algorithms is uses. Jess's
> performance on the standard Miranker rule-engine benchmarks is orders
> of magnitude better that CLIPS for large problem sizes, as has been
> independently measured. Jess' performance really shines in situations
> where there are many objects in working memory and your rules need to
> make comparisons across multiple memory elements.
>
>>
>> CLIPS (developed by NASA) is well documented and been the language of AI
>> systems for almost two decades. I learned Jess syntax from CLIPS
>> documentation.
>
> There are many commercial rule engines, Jess being but one; it's a
> large and thriving market. You'll have to draw your own conclusions there.
>
>>
>> Maybe I am wrong about Jess, but with my current perspective, i dont see any
>> good reasons to use Jess instead of CLIPS, C++, or even sole Java coding.
>
> I think you've hit the nail on the head right there: "with your
> current perspective," the reasons why rule engines are used aren't
> obvious to you. With some experience, you may come to understand.
>
> ---------------------------------------------------------
> Ernest Friedman-Hill
> Advanced Software Research Phone: (925) 294-2154
> Sandia National Labs FAX: (925) 294-2234
> PO Box 969, MS 9012 [EMAIL PROTECTED]
> Livermore, CA 94550 http://herzberg.ca.sandia.gov
> --------------------------------------------------------------------
> To unsubscribe, send the words 'unsubscribe jess-users [EMAIL PROTECTED] '
> in the BODY of a message to [EMAIL PROTECTED], NOT to the list
> (use your own address!) List problems? Notify [EMAIL PROTECTED].
> --------------------------------------------------------------------
>
>
--------------------------------------------------------------------
To unsubscribe, send the words 'unsubscribe jess-users [EMAIL PROTECTED]'
in the BODY of a message to [EMAIL PROTECTED], NOT to the list
(use your own address!) List problems? Notify [EMAIL PROTECTED].
--------------------------------------------------------------------
