Hammurapi Rules is a rules engine for Java developers. In Hammurapi Rules rules are developed in Java language. It supports forward and backward reasoning.
- Forward chaining through JSR-94 interfaces.
- Backward chaining. In many situations backward chaining is more appropriate and more efficient than forward chaining.
- Plain Java is used to write rules. Hammurapi rules leverages Java language semantics and several naming conventions to build inference chains.
- Rule sets are assembled and configured using XML.
- Multi-threaded inference.
- No need for Java developers to learn a specialized rules language. Developers stay focused because they don't have to switch between Java and other programming languages.
- The body of knowledge accumulated for Java development (e.g. testing, profiling, debugging, deployment, ...) can be applied to rules development. No need in specialized processes and tools.
- Full power of Java to implement rules logic.
- Rules get access to JVM and enterprise resources in the same way as other Java classes.
- Rules are compiled to bytecode by Java compiler, JVM takes care of optimizing rules execution at runtime.
- Parallel execution of rules in multiple threads.
- Same rules and rulesets can be used for forward or backward chaining depending on the problem at hand.
- Hammurapi rules provides means for rules parameterization through XML descriptor and rule session initialization parameters. It allows to implement flexible yet robust rules and rulesets which allow users to achieve their goals through parameterization with minimal risk of breaking things and without having to write code.