Mob Kata: Cellular Automata in Clojure

At this week's Clojure Developers Barcelona meetup, we did the Cellular Automata kata in Clojure.

We did mob programming and used a mix of TDD and RDD.

This is the code we wrote:

First, the tests using Midje for the rules 30 and 90:

	(ns cellular-automata.rules-test
	(:require
	[midje.sweet :refer :all]
	[cellular-automata.rules :as rules]))
	(facts
	"about rules"
	(fact
	;+-----------------------------------------------------------------+
	;| Neighborhood | 111 | 110 | 101 | 100 | 011 | 010 | 001 | 000 |
	;+-----------------------------------------------------------------+
	;| New Center Cell | 0 | 1 | 0 | 1 | 1 | 0 | 1 | 0 |
	;+-----------------------------------------------------------------+
	"rule 90"
	(rules/rule-90 [1 1 1]) => 0
	(rules/rule-90 [1 1 0]) => 1
	(rules/rule-90 [1 0 1]) => 0
	(rules/rule-90 [1 0 0]) => 1
	(rules/rule-90 [0 1 1]) => 1
	(rules/rule-90 [0 1 0]) => 0
	(rules/rule-90 [0 0 1]) => 1
	(rules/rule-90 [0 0 0]) => 0)
	(fact
	;+-----------------------------------------------------------------+
	;| Neighborhood | 111 | 110 | 101 | 100 | 011 | 010 | 001 | 000 |
	;+-----------------------------------------------------------------+
	;| New Center Cell | 0 | 0 | 0 | 1 | 1 | 1 | 1 | 0 |
	;+-----------------------------------------------------------------+
	"rule 30"
	(rules/rule-30 [1 1 1]) => 0
	(rules/rule-30 [1 1 0]) => 0
	(rules/rule-30 [1 0 1]) => 0
	(rules/rule-30 [1 0 0]) => 1
	(rules/rule-30 [0 1 1]) => 1
	(rules/rule-30 [0 1 0]) => 1
	(rules/rule-30 [0 0 1]) => 1
	(rules/rule-30 [0 0 0]) => 0))

view raw ca_rules_test.clj hosted with ❤ by GitHub

and the tests for the evolution and rendering of automata:

	(ns cellular-automata.core-test
	(:require
	[midje.sweet :refer :all]
	[cellular-automata.core :as automata]
	[cellular-automata.rules :as rules]))
	(facts
	"an elementary cellular automaton"
	(facts
	"evolves from an initial state for some time steps
	following a given rule"
	(automata/evolve
	rules/rule-90
	[1 1 0 1 0 1 0]
	5) => [[1 1 0 1 0 1 0]
	[1 1 0 0 0 0 1]
	[1 1 1 0 0 1 0]
	[1 0 1 1 1 0 1]
	[0 0 1 0 1 0 0]
	[0 1 0 0 0 1 0]])
	(facts
	"can be rendered as text lines"
	(automata/render
	[[1 1 0 1 0 1 0]
	[1 1 0 0 0 0 1]
	[1 1 1 0 0 1 0]]) => "xx x x \nxx x\nxxx x "))

view raw ca_core_test.clj hosted with ❤ by GitHub

This is the corresponding code for the rules:

	(ns cellular-automata.rules)
	(def rule-90
	{[1 1 1] 0
	[1 1 0] 1
	[1 0 1] 0
	[1 0 0] 1
	[0 1 1] 1
	[0 1 0] 0
	[0 0 1] 1
	[0 0 0] 0})
	(def rule-30
	{[1 1 1] 0
	[1 1 0] 0
	[1 0 1] 0
	[1 0 0] 1
	[0 1 1] 1
	[0 1 0] 1
	[0 0 1] 1
	[0 0 0] 0})

view raw ca_rules.clj hosted with ❤ by GitHub

and for the automaton evolution and rendering:

	(ns cellular-automata.core
	(:require
	[clojure.string :as string]))
	(def ^:private representations
	{0 " "
	1 "x"})
	(defn- extract-neighborhoods [state]
	(partition 3 1 (repeat 0) (cons 0 state)))
	(defn- evolve-once [rule state]
	(mapv rule (extract-neighborhoods state)))
	(defn evolve [rule initial-state time-steps]
	(->> initial-state
	(iterate (partial evolve-once rule))
	(take (inc time-steps))))
	(defn- render-state [line]
	(apply str (map representations line)))
	(defn render [states]
	(->> states
	(map render-state)
	(string/join "\n")))

view raw ca_core.clj hosted with ❤ by GitHub

Printing on the REPL the result of rendering the Rule 90 automaton evolution during 15 steps, we obtain a nice Sierpinski triangle :

	(doseq
	[line (render
	(evolve
	rules/rule-90
	[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
	15))]
	(print line))
	x
	x x
	x x
	x x x x
	x x
	x x x x
	x x x x
	x x x x x x x x
	x x
	x x x x
	x x x x
	x x x x x x x x
	x x x x
	x x x x x x x x
	x x x x x x x x
	x x x x x x x x x x x x x x x x => nil

view raw sierpinsky_ca_clj_in_repl.clj hosted with ❤ by GitHub

You can find the code in this GitHub repository.

As usual, it was a pleasure to meet and program with Clojure Developers Barcelona members.