Browse Books

Reviewer: Kevin Denis Reilly

Hill's book introduces the expert system (ES) shell, Jess, emphasizing Jess-Java integration, which is perhaps the shell's most interesting and powerful feature. Prior exposure to Java, Java Beans, and Enterprise Java Beans is deemed helpful. The Jess system and example code are available to book purchasers and teachers with no charge (under conditions restricting use). Jess nuts-and-bolts are covered first. In isolation, the purpose of these snippets (and associated limitations and restrictions) sometimes appears to be obscure. Fortunately, much is clarified when many of them are seen again in later examples. This fragment-centered discourse can perhaps be defended because it provides core details for a nontrivial system with approximately 200 functions. The overall coverage is orderly and systematic: facts, rules, and then inference mechanisms (a modified Rete algorithm). Java Beans and associated Jess shadow facts are presented early. Rules elucidations include an examination of constraints (literal, variable, connective, predicate, and return value); forward and backward chaining; and managing the agenda. This helps make the under the hood section short and sweet. The heart of the book is a series of four relatively large examples, and a final tract on Java Enterprise systems. The first example uses forward chaining for US tax forms recommendations, and could have come earlier in the book. Development issues, creating facts and rules, and testing incrementally evolve as a plan for orderly code sequencing exploiting modules. The second example takes Jess into backward chaining in a diagnostic system example. Flowcharts guide development and testing. Still, backward chaining in a system built for forward chaining seems inelegant at times. A nice feature is that functions from the prior case study are adapted here and support a Java Swing graphical user interface (GUI), without exiting Jess. Changes are made incrementally, but for some readers, an up-front, adequately explained complete solution could prove more palatable. The third large example focuses on Java in a realistic setting: a hardware-based, C-dependent system, accessible through Java's native interface (JNI), with a featured Java simulator. A diagram aptly depicts heat pump and vent control systems, but additional illustrations would help. Attention falls heavily on Jess's key Java-based extension method, a two-method interface called Userfunction. Though, as noted, the author touts testing from the start, it is not until halfway through a three-chapter treatment that testing is given single-page coverage. The final chapter of the section presents the rules. After this, about 15 pages on fuzzy rules provide a minimal introduction to the topic. In the first chapter of the fourth section, Java Server Pages (JSP) and servlets are evaluated against alternatives, and are elected for a purchase recommendation system: a person buys a DVD player, and the system recommends DVDs. Discussion includes building rule (antecedent) patterns; arguing over ordering them within rules; incrementing order numbers; and cleaning up after user-initiated midstream cancellations. The jess.Rete Java class provides an access point to the Jess library to promote jess.Fact object manipulation in Java, and allows more control than Jess alone. Exception handling and input-output end a round of discussion. Remarks on a Linux setting, makefiles, the Tomcat servlet engine, and small examples make linking the pieces into a final target system proceed smoothly, resulting in an architecture of one Hypertext Markup Language (HTML) file, three JSP files, and three servlet files. The final two chapters cover features of a standardization effort on the javax.rules application programming interface (API), which opens the Java 2 Platform, Enterprise Edition (J2EE) and Java 2 Platform, Standard Edition (J2SE) infrastructures to rule engines. The API helps manage rules and Java engine sessions. Coverage includes transforming Extensible Markup Language (XML) rule representations to Jess and back. In another tract, a remote method invocation (RMI) server is employed to wrap a Jess system for network use. J2EE restrictions lead to a two-part solution: a remote (object) version of the Jess rule engineer, and a factory class to create engine instances. The abbreviated treatment may leave the reader hungry for more. The book's emphasis is primarily on programming techniques. Interleaved generalities about other ES aspects often seem awkward. These are well covered elsewhere, and eliminating them here would provide about 100 pages for additional development of other topics, including fuzzy systems, and balancing object-oriented and rule features. A few misspellings and incomplete sentences seem minor compared to the need for more diagrams and in-code comments. Nonetheless, this is a good book that is comprehensive and yet generally readable. Why Jess should be used instead of Java (and vice versa) is covered. Said to be primarily designed for practitioners, the book could also be used in course work, although it could be a bit intense for a single term. Homework or project suggestions are not given, although it would be easy to supply them. Online Computing Reviews Service