JESS

JESS (Java Expert Shell System) is a rule engine and scripting environment originally developed at Sandia National Laboratories by Ernest Friedman-Hill. Written entirely in Java, JESS enables building expert systems by providing a forward-chaining inference engine based on the Rete algorithm. It allows developers to define rules in a Lisp-like syntax and integrate them seamlessly with Java code. JESS is widely used for applications in diagnostic, scheduling, and decision-support systems, particularly in academic and research settings.

1.1 History

JESS was first released in the mid-1990s by Ernest Friedman-Hill at Sandia National Laboratories. It was inspired by CLIPS (C Language Integrated Production System) but reimplemented in Java to leverage platform independence and object‑oriented capabilities. The early versions were distributed as free software, and the system quickly gained popularity in academic and research circles. Over time, licensing changed from a public‑domain model to a commercial license (see section 5.2). Development continued until version 7.1p2 (2014), after which it was largely superseded by other rule engines, though it remains in use in legacy systems.

1.2 Architecture

JESS architecture is built around three core components: the inference engine, working memory, and rule base. These components interact through the Rete algorithm to efficiently match rule conditions against facts.

1.2.1 Inference Engine

The inference engine is the central processing unit of JESS. It uses forward‑chaining to apply rules: when new facts are asserted or modified, the engine evaluates which rules are satisfied and then executes the corresponding actions. The engine implements conflict resolution strategies (e.g., salience, recency) to decide the order of rule firings. It also supports backward‑chaining through query mechanisms (see section 2.4).

1.2.2 Working Memory

Working memory holds all facts—data objects that represent the current state of the system. Facts can be simple values, Java objects, or ordered collections. The inference engine repeatedly matches rule patterns against the facts in working memory. Facts can be asserted, retracted, or modified during rule execution, and the Rete network is updated incrementally to reflect changes.

1.2.3 Rule Base

The rule base is a collection of rules written in the JESS scripting language (JJ). Each rule consists of a left‑hand side (LHS) of conditional patterns and a right‑hand side (RHS) containing actions (e.g., printing, calling Java methods, modifying facts). Rules are stored in a compiled form (Rete network) for efficient execution.

1.3 Comparison with Other Rule Engines

JESS is frequently compared to CLIPS, its direct predecessor in C. While CLIPS is written in C and can be embedded in C/C++ programs, JESS offers native Java integration, making it easier to combine rules with Java business logic. Drools, another popular Java rule engine, uses a different inference strategy (both forward and backward chaining) and a more modern API. Drools also provides a domain‑specific language (DRL) instead of JESS’s Lisp‑like syntax. JESS is generally simpler and lighter, but Drools offers better scalability for large‑scale enterprise applications.

2.1 Rete Algorithm Implementation

JESS implements the Rete algorithm, a highly efficient pattern‑matching algorithm for production‑rule systems. It builds a network of nodes that represent rule conditions; as facts are added or updated, the network propagates partial matches incrementally. This design avoids re‑evaluating the entire rule base on each change, making JESS suitable for real‑time and event‑driven applications.

2.2 Scripting Language (JJ)

JESS provides its own scripting language, JJ, which has a Lisp‑like syntax. The language supports variable binding, function definitions, loops, and conditional constructs. Rules are expressed using defrule constructs, with patterns enclosed in parentheses. JJ also allows direct retrieval and manipulation of Java objects.

2.3 Java Integration

One of JESS’s strongest features is seamless integration with Java. Rules can call Java methods, access Java fields, and create Java objects. Conversely, Java applications can load the JESS engine, assert facts, fire rules, and query the engine’s state. This bidirectional interoperability makes JESS a convenient rule engine for Java‑based software.

2.4 Backward Chaining Support (via Query)

Although JESS is primarily forward‑chaining, it supports backward chaining through the defquery construct. Queries allow the user to define patterns that can be used to ask the engine to search for facts that satisfy a given goal. This is useful for “what‑if” analyses and for integrating reasoning tasks that require goal‑directed search.

3.1 Simple Rule Definition

A typical JESS rule defined in the JJ language:

(defrule example-rule
   ?fact <- (temperature ?value)
   (test (> ?value 30))
   =>
   (printout t "Warning: high temperature " ?value crlf))

This rule fires whenever a temperature fact with a value greater than 30 is present in working memory, printing a warning.

3.2 Applying Rules to Java Objects

JESS can directly manipulate Java objects as facts. For example, after importing a Java class org.example.Sensor, a rule can match on a sensor object:

(import org.example.Sensor)
(defrule check-sensor
   ?s <- (object (is-a Sensor) (reading ?r))
   (test (> ?r 100))
   =>
   (call ?s setAlarm true))

Here the rule triggers when a Sensor object’s reading property exceeds 100, and calls a Java method to set an alarm.

3.3 Debugging and Tracing

JESS provides several built‑in debugging commands. The (watch rules) command enables tracing of rule activations and firings. The (watch facts) command prints additions and retractions of facts. The (agenda) function displays the current conflict set. These tools help developers understand rule execution order and diagnose unexpected behavior.

4.1 Expert Systems in Academia

JESS has been widely used in university courses on artificial intelligence, expert systems, and rule‑based programming. Its simple syntax and tight Java integration make it ideal for teaching rule‑based reasoning concepts. Many textbooks and tutorials have been published using JESS as the example platform.

4.2 Industrial Rule‑Based Systems

In industry, JESS has been employed in diagnostic systems, such as fault‑detection in telecommunications networks, and in scheduling applications for manufacturing. Its ability to integrate with existing Java codebases allowed companies to add rule‑based decision logic without rewriting their core software.

4.3 Prototyping and Research

Researchers in various domains (e.g., bioinformatics, robotics, and natural language processing) have used JESS for rapid prototyping of rule‑based components. Its lightweight engine and easy configurability made it suitable for small‑ to medium‑scale experiments where a full‑fledged enterprise rule engine would be overkill.

5.1 Performance on Large Rule Sets

JESS’s performance degrades as the number of rules and facts grows beyond a certain threshold. The Rete network overhead can become significant, and the engine does not support parallel execution or distributed processing. For large‑scale commercial applications, alternatives like Drools or IBM Operational Decision Manager are often preferred.

5.2 License Changes (from Public Domain to Commercial)

Originally distributed as public‑domain software, JESS’s license changed in late versions to a commercial model (Sandia National Laboratories’ proprietary license). This change limited its adoption in open‑source projects and prompted many users to migrate to free rule engines such as Drools. The last freely available version (7.0) is still used by some legacy systems, but no further updates were released under an open‑source license.

6.1 CLIPS

CLIPS (C Language Integrated Production System) is a rule‑based programming tool developed at NASA. It served as the primary inspiration for JESS. CLIPS is written in C and can be embedded in C/C++ programs. It also uses the Rete algorithm and supports both forward and backward chaining. Unlike JESS, CLIPS remains free and open‑source (public domain).

6.2 Drools

Drools is a modern, open‑source business rule management system (BRMS) written in Java. It provides a rich domain‑specific language (DRL), a rule‑based event processing engine, and integration with Java Enterprise Edition. Drools scales better than JESS for large rule sets and is actively maintained by the community under the Apache License.

6.3 Rete Algorithm Variants

Several other systems implement the Rete algorithm or its derivatives. These include Soar (a cognitive architecture), OPS5 (an early production‑system language), and the Rete engine used in the Lisp‑based ART (Automated Reasoning Tool). Each variant optimizes pattern matching for specific use cases, such as real‑time performance or memory efficiency.

• Expert system
• Forward chaining
• Production system (computer science)
• Rule engine

• Friedman-Hill, E. (2003). *JESS in Action: Rule-Based Systems in Java*. Manning Publications.
• Sandia National Laboratories. (2014). JESS 7.1 documentation.
• Giarratano, J. C., & Riley, G. (2005). *Expert Systems: Principles and Programming* (4th ed.). Course Technology. (Discusses CLIPS and JESS.)