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]
--------------------------------------------------------------------
