Customer Reviews

Jess in Action: Java Rule-Based Systems (In Action series)

5 star:		(8)
4 star:		(3)
3 star:		(1)
2 star:		(0)
1 star:		(0)

 

 

Jess in Action presents the Jess rule-based framework, and explores it through four meaty and well-chosen examples: a console tax forms advisor, a console PC repair assistant, a Swing HVAC controller, and a servlet-based purchasing agent. The examples vary greatly in their designs and styles of interaction between Jess and Java, and expose patterns in a concrete context. It's especially nice the way each example builds on the functionality of the one before, such as a text-based question/interview module that is extended into a Swing GUI.

The book starts with an introduction to rule-based systems, goes through the basics of the Jess language, and then dives into the examples; the appendices include API references to both Jess functions and Jess's Java APIs, and numerous links and references are scattered throughout the book. If I have any complaint about the organization, it's that the book could have been even more example-driven, abandoning (or shortening) the chapter on syntax and basic functions and introducing them only when used in an example; the rest could have been left to the appendix of Jess functions.

The book is interesting and readable but dense with concepts, so its only 388 pages of content and 50 pages of appendices will take some (well-spent) time to get through. A second skimming impressed me anew with the richness of the material, and the productive way in which it's presented, so I recommend reading the book once to get the overall feel, and then going through it again with the working Jess command shell, editor, and command line in front of you. Or an IDE if you must. :-)

Jess itself consists of a rule language, a runtime engine which supports forward and limited backward-chaining, and APIs for integration with Java; there are many add-on tools for Jess, referenced throughout the book. As with most rules engines, rules are specified as declarative patterns, not procedural code.

Jess in Action is well worth your time and attention, at the least for its exploration of rules, and at most for presenting a strong, flexible platform to tackle what is probably one of the uglier parts of your development: the sequencing and parameterization of business decisions. Although the list of Cons below is longer, they're just nit-picking; this is an excellent, entertaining, and productive read that will likely expand your programming horizons considerably.

Pros
* Clearly, concisely, and entertainingly written for Java programmers of any background
* A strong introduction to two important topics: rules and declarative programming style
* Well-chosen and developed working examples, each with a different design style
* The description of the author's unit test framework for rules in Appendix C is a nice touch

Cons
* Early discussion of Jess syntax focuses too much on Java-like procedural style
* More of a tutorial - not long enough to be a good reference (though that would probably require a detailed Jess Patterns book)
* Discussions of development methodology and knowledge engineering are unnecessary, as they're covered better elsewhere and a short summary adds little to the book
* There's no single list of rule and Jess-related links; references to tools and discussions are scattered throughout the book
* There are no general references to rules and rule-based systems for theory and background

Jess is a rule engine written in Java. This book is not about rules engines, although it does have a brief introduction to rules engines. This book is about Jess. In fact, this book is the book on Jess. If you are interested in learning what kind of problems Jess can be used to solve and how to use Jess to solve these problems then this book will answer your questions.

The book is basically divided into two sections. The first section is a tutorial on Jess. This section starts by showing how to install and configure Jess. The rest of this section covers the Jess syntax and demonstrates how to write rules for Jess. The tutorial is clearly written with some simple examples that do a good job of helping to make Jess understandable. The tutorial even shows how to do some optimizations for the rules that you write.

The rest of the book covers some fairly complicated applications written using Jess. The author refers to this section as a cookbook and the examples are complex enough and explained so well that it could easily serve this purpose. The best part of this section is that it will help someone who isn't familiar with rules engines develop ideas about how they might implement a rules engine to solve their own business requirements. The examples themselves cover integrating Jess with Java both in typical client based applications and J2EE web based applications.

If you are interested in using Jess as a possible solution to your business needs then this book is a virtual necessity. I couldn't imagine trying to use Jess without this book.

This review is a long time in coming, and I apologize to Dr. Friedman-Hill for not doing it sooner.

I have read Jess In Action (affectionately known as JIA to Jess developers) cover to cover at least ten times since first interviewing Dr. Friedman-Hill about Jess in the summer of 2003 -- see http://www.devx.com/Java/Article/17651/0. Prior to that, I'd experimented with Jess since 4.0.

Dog-eared, annotated, and now held together by a rubber-band and Post-Its, JIA is always within reach when I'm programming Jess. It is a testament to Dr. Friedman-Hill's smooth yet dense style that every pass through revealed something that I missed before: the sign of a great book. All technical books start off like a roller-coaster, slowly ramping up the fundamentals and then hurling you through topical twists and turns towards the "advanced topics" and appendices that mark the end of the ride. Most times, I want my money back. Jess In Action is the first tech-tome in a long time that made me say, "Wow!! That was @#&* cool!" and head back to Chapter One for another ride.

Let me refute a few unfounded criticisms that I've seen:

1. JIA "...is more of a tutorial - not long enough to be a good reference."
It is true that this is more a collection of tutorials than a "cook-book" reference: this is by design. There are ample reference materials available with Jess's distribution, and to replicate those here would be extraneous. There is no substitute for doing your homework and reading the documentation if you want to be a competent Jess programmer. I recommend that you actually do this first, then get JIA. That way, it's like having Dr. Friedman-Hill explain Jess in-person.

2. JIA's "...early discussion of Jess syntax focuses too much on Java-like procedural style."
If you are new to declarative programming, and LISP-like syntax in particular, then having an early functional and procedural focus is pedagogically comforting for several reasons.
a) You aren't abandoning everything you know about procedural coding at once.
b) Jess is a Java API, and even object methods are still procedural.
c) The right-hand side of rules are mostly composed of functions, which contain procedural code.

3. JIA has "... no general references to rules and rule-based systems for theory and background."
Rule-based expert systems are the oldest and most studied of the major expert system types, and there is an enormous body of literature for the serious student. This raises an important point: You should study the kinds of problems that rule-engines and rule-based expert systems are meant to solve before you launch into hardcore Jess programming. In this regard, JIA gives quite a good sampling of what Jess can do without burying you in minutia. For a good overview of rule-based expert systems, I recommend Expert Systems: Principles and Programming, Fourth Edition by Joseph C. Giarratano, Gary D. Riley ISBN: 0534384471 as companion volume to JIA..

My Nit-Picks for 2nd Edition Features:
· Edit the index! I was miffed that there were innumerable newbie terms that I couldn't find (specifics escape me now), but I was greatly amused to find "rubber ducks" (p. 295) and the proverbial "kitchen sink" (p.114).
· Add a section on integrating Jess with agents. The agent folks who write about adding Jess to their code never seem get it right, and I trust that Dr. Friedman-Hill will.
· Add a Survey of Best Practices and Jess Design Patterns.
· Add latest stuff about leveraging/optimizing the JessDE.

Overall, JIA 1.0 is THE essential volume for the serious Jess developer, and I eagerly await the next edition!

Jason Morris - Morris Technical Solutions LLC
Jess Consultant and Co-Moderator - Jess Listserver

I see two ways to avoid writing a hard-to-use book about a complex product: one, write a book you wish existed when needed it. Or, if you've brought something new to the world, write about it so that anyone could understand what it does and how it works. I think Friedman-Hill has managed exactly that.

It's not easy for an expert to discuss the fundamentals of a creation as if it was altogether new, but Friedman-Hill manages this with good humor, a light touch, and most importantly a natural ability to describe how using rules-based engines can provide real power to the program designer.

As both guide and reference, this book has helped me apply Jess and reinforce my understanding of other ways to take advantage of it. When I first came across the website for Jess years ago, there wasn't enough context there for me to figure out where to start. With this book in hand I wrote some prototypes, learned how the engine worked, and started looking for effective ways to incorporate this tool into other tasks.

This book is best used by a self-starting, proficient programmer who is looking for powerful ways to tackle complex problems. For those who might need more motivation to invest their time, you'll just have to work a little harder. This is the only book available on the subject, and while the explanations run smoothly, feeling comfortable with Jess will take some time. That said, you should do it; you'll (eventually) be glad you did.

This is a fine book; I rate it 4 stars because it's the only book available on the subject. It's clear, well-written, informative, and entertaining -- for a nerd, anyway -- but I like to believe there's room to improve on it, and maybe even room for a "best" book. Nonetheless, your money will certainly be well-spent right here.

Author is the creator of Jess. The book is as well put together as the product itself. It doesn't assume any jess (or rules) expertise, and doesn't drag on with details you wont care about. Concisely covers the essential basics and moves on to non-trivial examples. As you follow the lead of the author in these examples you don't just understand the workings of jess, but also develop the thought process required to design rules based applications.

Time well invested.

I took a college course in AI in which the primary language was JESS and this book saved my life. It's not written as a textbook but more as a guided walkthrough for learning the language full of rich and helpful examples that cover both basic and advanced functionality. I highly recommend this book as a great way to get started with JESS or even as a reference book for people familiar with the language

This book is an excellent way to learn about rule-based systems in general and Jess in particular. The author also does a good job of describing the Rete algorithm, which is what Jess's engine is based on.

This book is one of the best references out there, for creating rule based engines. Very systematically explained concepts and good examples for users with any level of experience. A must have!

Jess in Action: Java Rule-Based Systems (In Action series)
This was my first introduction to rules based system and Dr. Friedman-Hill has done a really outstanding job of not only explaining the concepts but also providing enough practical examples to really see how this works in the real life. Furthermore, the books includes the software (Jess) so you not only have the book but the software to experiment.

Jess is a rules engine with excellent Java interplay. "Jess in Action" is a fast and swift read. Actually using Jess is surprisingly difficult.

In "Jess in Action", you will read about the Jess syntax (facts and rules), how it interplays with Java (scripting Java from Jess, Java Beans as shadow facts, calling Jess from Java) and very extensive examples with very detailed backgrounds.

All for version 61p4. The current Jess version is 71p2. As a bonus one can download from the books website a nonprofit version of Jess without a time limit. Unfortunately: Jess is not open source.

If you want to do some Jess, "Jess in Action" is an excellent complement for the online documentation.