Rules Engines:

Logic As Data Structure

Jarrell Waggoner / @malloc47


About Me


Big Data-○-Software Development-○-Clojure

I do A.I.

Computer Vision-○-Image Processing-○-Machine Learning

what is this I don't even

What is a Rules Engine?

Related Terms

  • Expert Systems (1970s-1980s)
    • Knowledge Base
    • Inference Engine
  • Business Rules
  • Rete Algorithm (1974-2010)

A Rules Engine is an...

Expert system that applies an inference engine to a knowledge base consisting of if/then rules and facts, executing arbitrary actions or inserting new facts when a rule matches.

In practical terms

  • If/then rules: specified in a DSL and "compiled" into the knowledge base
  • Fact: base language object (Java object, Ruby hash, Clojure defrecord, etc.)
  • Knowledge base: special graph that connects rules and facts together
  • Inference Engine: Rete Algorhtm

Rete Algorithm

  • Latin for 'net' or 'comb'
  • Represents rules as a (directed acyclic) graph
  • Trades memory for increased speed
  • Performance is (theoretically) independent of the total number of rules
  • Forward chaining vs. backward chaining used by Prolog

Rete Algorithm Visualization


Popular rules engines:

Rules Engine


learn your rules

College Application Processor

  • Facts: applicant, parents, grades
  • Rules: acceptance criteria, financial aid criteria


(defrecord Applicant [name age])
(defrecord Grade [type score])
(defrecord Parents [income alumni?])

(defrecord Accept [])
(defrecord Aid [amount])

Must use facts for input and output

Rule 1

(defrule good-enough-grades
  [Grade  (= type :gpa) (> score 3.0)]
   [Grade (= type :sat) (> score 1500)]
   [Grade (= type :act) (> score 20)]]
  (insert! (->Accept)))

Rule 2

(defrule rich-parents
  [Parents (> income 2000000)]
  (insert! (->Accept)))

Rule 3

(defrule aid-package
  [Applicant (< age 26)]
  [Parents (< income 60000)]
  (insert! (->Aid 20000)))

Run Rules Engine

(def facts
  [(->Applicant "Phil" 22)
   (->Parents 50000 false)
   (->Grade :gpa 3.1)
   (->Grade :sat 1650)])

(defn run-rules []
  (let [session
        (-> (mk-session ' :cache false)
            (insert-all facts)
    #_(print results here))


Accepted: true
Aid     : 20000





Rationale for Rules Engines

  • Rules as first class
    • Composable
    • Testable
    • Serializable
  • Clean separation of data and logic
  • Logic aggregation
  • Scalable both horizontally and vertically
  • Auditable (rule triggers can be "explained")
  • Visualizable (rules are data; can be graphed)

When to use a rules engine?

  • Lots of branching logic in rules
  • New entities may be introduced/removed
  • Rules constantly changing (commit hot-spots)
  • Non-technical stakeholders need to change rules
  • Your system has logical knots: complex dependencies on arbitrary logic and data


=> The End