clojure.lang.dk

When I saw that clojureql I wondered what the fuzz was about and decided to try it out on a small example.

Everybody who has read Programming Clojure, has been through the snippet server example in chapter 9.3, so that became the target for my experiments

As it happens, the only changes I had to do to snippets.database was including the appropriate library …

(:refer-clojure 
 :exclude [take drop sort distinct compile conj! disj!])
(:use clojureql.core)

… and then rewriting the few functions that interacts with the database.

(defn select-snippet [id]
  (first @(select snippets (where (= :id id)))))

(defn insert-snippet [body]
  (:id (last @(conj! snippets 
                     {:body body 
                      :created_at (now)}))))

… that’s it! The code ended up being shorter and easier to understand.

At this level clojureql was very nice to work with. The fact that it is possible, at all times, to get at the sql expression that I worked with was very useful.

A lot of people have responded to 10 Scala One Liners with implementations in a lot of different languages, including clojure. My suggestion can be found in this gist but one of the one-liners are especially interesting, Sieve of Eratosthenes.

There are a lot of different versions of this algorithm. This one is translated from Miranda, an old classic from Bird & Wadler, Introduction to Functional Programming, p.175, and goes something like this:

(defn sieve [xs]
  (filter #(not (zero? (mod % (first xs)))) (rest xs)))

(defn rsieve [xs]
  (map first (iterate sieve xs)))

(defn primes-below [max]
  (take-while #(not (nil? %)) 
	      (rsieve (range 2 max))))

Unfortunately, it blows the stack for large values, but I still like this simple compact definition.

..where I realize that each point can be calculated in parallel.

Determining the inclusion in the Mandelbrot Set is relatively easy to define.

(defn mandelbrot?
  ([x y]
     (mandelbrot? (complex x y)))
  ([z]
     (loop [ c 1, m (iterate #(+ z (* % %)) z) ]
       (if (and (> 64 c) (< (abs (first m)) 2))
         (recur (inc c)
                (rest m))
         (if (= 64 c) 0 c)))))

Running through all the points in an interesting range and projecting them to an area of a desired width and height. Here, I decided that the interesting range should include the usual, easily recognizable set.

(defn mandelbrot [width height]
  (for [x (indexed (stepped-range -2  0.5 width))
        y (indexed (stepped-range  1 -1   height))]
    [(first x) (first y) (rem (mandelbrot? (second x) (second y)) 256)]))

With the lazy sequence, the entire area can be plotted:

(defn draw-mandelbrot [width height]
  (let [menu-bar-height 23
        border-width     3]
    (.clearRect gfx 0 0 (+ width border-width) (+ height menu-bar-height))
    (.setSize frame (Dimension. (+ width border-width) (+ height menu-bar-height)))
    (doseq [[x y v] (mandelbrot width height)]
      (plot (transform x y) (colors v)))))

The “(doseq ” is not very practical for parallel processing and I realized that it can be rewritten as “(dorun (map ” like this

(dorun (map (fn [[x y v]] (plot (transform x y) (colors v)))
            (mandelbrot width height)))

… and suddenly, it’s a simple matter of changing map to pmap to get the calculations processed in parallel.

In this case, there doesn’t seem to be much benefit in this. Even on my dual-core iMac, the parallel version is only a bit faster than the sequential version. BUT, it was easy to switch from one to another .. and I am probably missing something.

The code is available on github

The 12th of december 2008, the word “clojure” enters my vocabulary for the first time. I was looking at sbcl/clisp and reading Practical Common Lisp and had done the classic Casting SPELs in Lisp at the time and figured that Clojure might be more interesting to look at.

In the beginning of 2009, setting up clojure was a pain and I might have used more time making emacs do what I wanted than looking at the language. Participation in JAOO and reading “Programming Clojure” in September 2009 was really what gave me the big kick-start.

I found RosettaCode in December and contributed the clojure solution for a few tasks .. then I found Project Euler and for the next 6 months, I went from using the problems to learn clojure to using clojure to solve problems. The REPL and the exploratory aspect of problem research is really awesome but at some point solving Project Euler problems does not add anything new to learning a programming language.

… I got to explore some other angle.