Jess, the Java Expert System Shell

13. Release Notes

13.1. Porting from Jess 5 to Jess 6

Jess 6 introduces many new features, but it is mostly backwards compatible with Jess 5. This section lists a few specific areas where Jess 5 applications may need to be changed to work with Jess 6.

Java 2 is required. Jess 6 now requires a Java 2 compatible JVM (JDK 1.2 or later.) Jess 5 worked with JDK 1.1.
Batch files in JAR files. The rules for loading a batch file from a JAR have changed. See the javadoc for java.lang.Class.getResource() for the appropriate way to reference a batch file in a JAR.
Strategy interface changed. If you wrote any custom conflict resolution strategies for Jess 5, they need to be rewritten from scratch for Jess 6.
No functions are optional. Under Jess 5, you had to load a number of optional Userpackages using Rete.loadPackage(). In Jess 6, there are -no- optional functions; everything is loaded by default. Loading packages redundantly does no harm, it's just inefficient. More seriously, some of the old optional packages either no longer exist, or no longer support the Userpackage interface. Simply delete any code you have in your app which calls Rete.addUserpackage() on a Jess-supplied package.
Script library loaded automatically. Under Jess 5, you had to load the Jess script library manually; in Jess 6, it happens automatically. There's no harm in loading it redundantly, but there's no value in it, either.
Pattern bindings are jess.Fact objects. Perhaps the biggest change is that pattern bindings, like ?var in
```
            ?var <- (pattern)
          
```
are jess.Fact objects in Jess 6, not just integers as they were in Jess 5. That means that Jess 5 code like
```
            ;; Get the 'head' of a fact
            (get (call (engine) findFactById ?var) name)
          
```
won't work. Instead, it can be replaced by the much simpler and much more efficient
```
            ;; Get the 'head' of a fact
            (get ?var name)
          
```
Some fairly widely distributed code needs to be updated in this way.

13.2. Limitations of Jess 6.0

Reality being what it is, no software is ever truly perfect. This section lists a few areas where features, fixes, and enhancements intended for this release of Jess didn't make it in, or known issues didn't get dealt with. In general, all of these should be done for Jess 6.1.

Variable matching across multiple patterns in not conditional elements. The rewriting scheme used to handled grouping CEs in this version of Jess is imperfect. In particular, a rule like
```
            (defrule example
              (not (and (A ?X) (B ?X)))
              => ...       
          
```
will throw an exception "negated conjunction with unbound variables" at runtime.
Possible time inversion in breadth conflict resolution strategy. Under some circumstances, when using the breadth conflict resolution strategy (as opposed to the default depth strategy) you may observe rules firing in an incorrect order.
logical facility Java interface is sparse. If the implementation of the logical conditional element had a broader public interface, it could be used to build an explanation facility. Right now there is no public interface to speak of.
Contexts and eval The eval function doesn't have access to variables defined in the current context, although it should.
The format function format should support a %n command, but does not.
Support for parser extensions The Jess parser is monolithic and brittle. There are any number of situations in which the user might want to extend it, but currently there's no API for doing so. There isn't even a public API for parsing specific constructs on demand. The whole parser will be rewritten with support for extensions, probably including a defmacro facility.
RU.LONG not a first-class type The RU.LONG type is poorly supported; there are no long literals, for example. When the parser is rewritten, this will be remedied.
Backwards chaining during run-query The run-query command executes run(10). There should be a way to control that number.
Defclass and Deftemplate inheritance defclass and deftemplate constructs should be able to freely inherit from each other, but in general it doesn't work except for two defclasses or two deftemplates.
assert and JDK 1.4 In JDK 1.4, assert is now a Java keyword. Unfortunately, the Java assert() function in jess.Rete is called by virtually every Java program that uses Jess. I'm going to have to deprecate, then remove, the assert() function.
view with rule name broken If you give view a rule name as an argument, the window that appears is blank.
You can't print the manual. HTML isn't very good for printing. A PostScript version of the manual will be released.

Back to index