I came up with the idea of writing a Clojure function to check if a given string is a palindrome.

I remember the moment very well when I stumbled upon the (conj) function and learnt that it behaves slightly different when executed with a list or an array.

user=> ;; use conj with a list (mind the quote mark)
user=> (conj '(1 2 3) 0)
(0 1 2 3)
user=> ;; use conj with an array
user=> (conj [1 2 3] 0)
[1 2 3 0]

I think that in order to fully embrace the concept of functional programming is to use the three functions: map, reduce and filter extensively, and so I insisted on using them to tackle the problem.

Here’s the function I developed to check whether a given string is a palindrome or not.

user=> (defn my-reverse [s]
         (let [lst (list)]
           (reduce #(str %2 %1)
                   (mapcat #(conj lst %1) s))))
#'user/my-reverse

user=> (defn palindrome? [s]
         (= s (my-reverse s)))

user=> (is (palindrome? "21022012"))
true

I solved the problem, but with mapcat not map. Is there a way to use just the three functions – map, reduce and filter?

I use lein to manage Clojure projects and learnt to use lein compile.

There’s an issue with lein compile – it doesn’t compile all the available sources which was the feature I was looking for.

To use lein compile you’ll have to define :main [namespace] which will only compile the main namespace pointed out by the namespace option.

(defproject librarian-clojure "0.0.1-SNAPSHOT"
  :description "Book manager in Clojure"
  :url "http://github.com/jaceklaskowski/librarian-clojure"
  ;; removed to ease reading
  :main librarian-clojure.run)

Run lein compile and you’ll see your main namespace compiled.

jacek:~/oss/librarian-clojure
$ lein compile
Compiling librarian-clojure.run
Compilation succeeded.

I often consult a source code to find answers if it’s available. The sources of the compile task are available, and it’s just a matter of time how much you’ll gain studying the sources. I don’t think you need much to learn a lot.

At line 30 of the compile task I found the value :all of the :aot option. That was it!

(defproject librarian-clojure "0.0.1-SNAPSHOT"
  :description "Book manager in Clojure"
  :url "http://github.com/jaceklaskowski/librarian-clojure"
  ;; removed to ease reading
  :main librarian-clojure.run
  :aot :all)

With the change in project.clj, lein compile now processes all the namespaces in the project. Huurray!

jacek:~/oss/librarian-clojure
$ lein compile
Compiling librarian-clojure.run
Compiling librarian-clojure.books
Warning: *server* not declared dynamic and thus is not dynamically rebindable, but its name suggests otherwise. Please either indicate ^:dynamic *server* or change the name.
Compiling librarian-clojure.core
Compiling librarian-clojure.repl

Type (go) to launch the server and run a browser.
Type (stop) to stop the server.

Compiling librarian-clojure.run
Compilation succeeded.

Konrad Garus pointed out at org.joda.time.format.PeriodFormatterBuilder that would do this.

The following is a possible answer to my question of formatting the age of my youngest son up to minutes. Note how I almost directly copied the Java version to create the Clojure one. Ideas and comments welcome.

(import 'org.joda.time.format.PeriodFormatterBuilder)

(defn format-age [interval]
  (let [builder (doto (PeriodFormatterBuilder.)
                      (.printZeroAlways)
                      (.printZeroRarelyLast)
                      (.appendMonths)
                      (.appendSuffix " month" " months")
                      (.appendSeparator " and ")
                      (.appendDays)
                      (.appendSuffix " day" " days")
                      (.appendSeparator " and ")
                      (.appendHours)
                      (.appendSuffix " hour" " hours")
                      (.appendSeparator " and ")
                      (.appendMinutes)
                      (.appendSuffix " minute" " minutes"))
        formatter (.toFormatter builder)]
    (.print formatter interval)))

(use 'clj-time.core)

(def maksym-birth-date-time (date-time 2011 10 03 17 23))

(def maksym-interval (interval maksym-birth-date-time (now)))

(format-age (.toPeriod maksym-interval))

(in-weeks maksym-interval)

When you run it, it should print out the following output:

user=> (format-age (.toPeriod maksym-interval))
"4 months and 6 days and 4 hours and 25 minutes"
user=> (in-weeks maksym-interval)
19

By a complete chance I stumbled upon this function which I happily incorporated in the librarian-clojure project. The function requires a URL to be open, e.g.

$ lein repl
REPL started; server listening on localhost port 44510
user=> (clojure-version)
"1.2.1"
user=> (clojure.java.browse/browse-url "http://clojure.org")
"http://clojure.org"

Once you call this function the default browser will open with the page. Quite handy, isn’t it? And the sources of the function are easy to read through as well. It takes a mere minute.

It turned out that the function was already in my project (when I copied the part off the other project), but I had no time to read about and ultimately learn it. Now I did.

By the way, I don’t recommend reviewing the application as it appears quite old, and perhaps often misleading in its use of the web libraries. Stay away of it.

I’m working on a side project – librarian-clojure – which aims at providing a CRUD-like web application to manage books and when a colleague Konrad Garus cloned it to his own repo where he made some changes to, I was asking myself how to merge his changes with the repo I work with.

The project librarian-clojure is also aimed to let me learn Clojure and its web ecosystem, git and GitHub, and finally Heroku. Lots of stuff I’ve never worked with before. Git is amongst them.

So, I was wondering about merging the changes with the repo of mine. I’ve been hearing about pull requests on GitHub, but didn’t have time to grasp it. I emailed Konrad asking about it and hoping he would know the answer. He did. Early in the morning next day I found a pull request. Just at the same time when I pulled his changes to my repo and pushed them to GitHub. I remember I had to use git stash, too, while applying his changes. Quite intensive git self-learning.

The other day I was reading a blog post of Sean Corfield – Testing your project against multiple versions of Clojure where he described how to unify a set of dependencies in a Clojure project. I did use it in the librarian-clojure project and also found a note in Midje’s project.clj (the version I’m reffering to is this version of project.clj):

“;; TODO: Alex Jan 29, 2012 – figure out how to not duplicate these deps”

That was a call to action for me!

I had known how to do it so it was a matter of copying and pasting the solution I had found in Sean’s blog post. That’s how a pull request of mine was born. It didn’t take long before Alex accepted the change and it’s now a part of Midje.

It’s rewarding when a change doesn’t take much but stays longer.

I decided to use it in a side project of mine – librarian-clojure. I ran lein run to see what would happen.

jacek:~/oss/librarian-clojure
$ lein run
No :main namespace specified in project.clj.

Ouch, but not much. The error message said it all. Easy stuff, wasn’t it?

It also reminded me about Procfile for Heroku where I entered a quite similar command.

jacek:~/oss/librarian-clojure
$ cat Procfile
web: lein run -m librarian-clojure.core $PORT

It worked fine on the command line.

jacek:~/oss/librarian-clojure
$ lein run -m librarian-clojure.core 8080
...
2012-02-11 20:29:46.756:INFO::Logging to STDERR via org.mortbay.log.StdErrLog
2012-02-11 20:29:46.773:INFO::jetty-6.1.25
2012-02-11 20:29:46.857:INFO::Started SocketConnector@0.0.0.0:8080

With :main librarian-clojure.core in project.clj I ran lein run again.

jacek:~/oss/librarian-clojure
$ lein run
Exception in thread "main" clojure.lang.ArityException: Wrong number of args (0) passed to: core$-main
     at clojure.lang.AFn.throwArity(AFn.java:437)
     at clojure.lang.AFn.invoke(AFn.java:35)
     at clojure.lang.Var.invoke(Var.java:397)
     at user$eval53.invoke(NO_SOURCE_FILE:1)
     at clojure.lang.Compiler.eval(Compiler.java:6465)
     at clojure.lang.Compiler.eval(Compiler.java:6455)
     at clojure.lang.Compiler.eval(Compiler.java:6431)
     at clojure.core$eval.invoke(core.clj:2795)
     at clojure.main$eval_opt.invoke(main.clj:296)
     at clojure.main$initialize.invoke(main.clj:315)
     at clojure.main$null_opt.invoke(main.clj:348)
     at clojure.main$main.doInvoke(main.clj:426)
     at clojure.lang.RestFn.invoke(RestFn.java:421)
     at clojure.lang.Var.invoke(Var.java:405)
     at clojure.lang.AFn.applyToHelper(AFn.java:163)
     at clojure.lang.Var.applyTo(Var.java:518)
     at clojure.main.main(main.java:37)

Clojure is known for “its elaborative exception messages” (quoting Stuart Halloway who said that the situation is “because Rick doesn’t make mistakes” at 00:47:30), but in this particular case, it didn’t take much to figure out that the -main function in librarian-clojure/core.clj offers no no-args version of itself.

With a small change that ultimately helped me to master the format of a function definition with different args, the project boots up now with a simple lein run.

(defn -main
  ([] (-main 9999))
  ([port] (run-jetty app {:port (Integer. port)})))

I believe I need a librarian-clojure/main.clj to copy the above method to and have another one to fire up a browser with the URL for the application – something similar to ClojureScript One’s repl.clj.

People interested in lein run‘s internals are requested to visit leiningen.run.

While scanning Clojure mailing list I stumbled upon [ANN] Clojure Hangman from Jozef Wagner and hoping to learn a bit about Clojure and its libraries I cloned into https://github.com/wagjo/hangman (btw, I would not have used the term ‘clone into’, but that’s how it’s printed out upon cloning so I consider it correct).

In the blink of an eye, I found a few things in the hangman project I hadn’t known before – I learnt lein run, noticed Incanter in the libs downloaded (which I’ve always been meaning to learn) and finally noticed that opencsv (although it wasn’t supercvs it instantly reminded Stuart’s presentation). All in one shot which I truly appreciate. And it’s free to use, modify, study, whatever, you name it. Just clone the repo and it’s yours.

And I could play a little while getting accustomed with the tool. The first time I ran the app, I failed to answer the word correctly and guess what the word was. DANGER. Seriously. Happily the second attempt was quite successful!

Time for studying the sources. I hope to find some hidden gems there, too.

BTW, I’ve always been wondering how others use Eclipse Counterclockwise (CCW) to create and/or import Clojure projects. With yesterday’s beta release of CCW – 0.6.0 Beta of Counterclockwise it looks like an excellent moment to try it out yourself. Do you just point the location to the directory of your project and type in the project’s name? I would expect some sort of import, but I can find no such a feature. Let me know your way.

Lein is pretty easy to start with – just type in lein new with the name of your project and you’re done.

jacek:~/oss
$ lein new maksym-age-clojure
Created new project in: /Users/jacek/oss/maksym-age-clojure
Look over project.clj and start coding in maksym_age_clojure/core.clj
jacek:~/oss
$ cd maksym-age-clojure

After all the book readings, I learnt that when you design an application in Clojure, use Java classes and libraries as much as possible (but not overly much!). I remembered when Stuart Halloway mentioned a Clojure library for Joda Time during his talk about Clojure – Clojure in the Field (at 00:36:35) so I googled it to see if there’s a more recent version.

There is one – Sean Corfield’s clj-time – a date and time library for Clojure, wrapping the Joda Time library. It seemed a perfect fit for my needs.

I vi’ed project.clj and added the library.

jacek:~/oss/maksym-age-clojure
$ cat project.clj
(defproject maksym-age-clojure "1.0.0-SNAPSHOT"
  :description "Calculate Maksym's age in Clojure using Joda Time library"
  :dependencies [[org.clojure/clojure "1.3.0"]
                 clj-time "0.3.5"])

Note: I don’t know how to tell WordPress to display :dependencies correctly so it contains clj-time “0.3.5″ in the brackets. Anyone?

I ran lein deps and hopped into Clojure’s REPL with lein repl. No overly complicated stuff – quickly and easily.

jacek:~/oss/maksym-age-clojure
$ lein deps
Downloading: clj-time/clj-time/0.3.5/clj-time-0.3.5.pom from repository central at http://repo1.maven.org/maven2
...
Copying 3 files to /Users/jacek/oss/maksym-age-clojure/lib
jacek:~/oss/maksym-age-clojure
$ lein repl
REPL started; server listening on localhost port 46468
user=>

Reading the readme of the clj-time project is almost like being guided by a mentor who knows what you’re up to if you’re in the room (i.e. on the project’s website). It’s concise and exactly to the point. No troubles along the way. It is during such moments when I wonder how people can claim programming is a huge undertaking?!

I moved along importing the clj-time.core (the use function) and the other functions which I doubt anyone would find hard to comprehend.

user=> (use 'clj-time.core)
WARNING: extend already refers to: #'clojure.core/extend in namespace: user, being replaced by: #'clj-time.core/extend
nil
user=> ; maksym was born on 10/03/2011 at 17:23 CET
user=> (def maksym-birth-date-time (date-time 2011 10 03 17 23))
#'user/maksym-birth-date-time
user=> (in-months (interval maksym-birth-date-time (now)))
4
user=> (in-weeks (interval maksym-birth-date-time (now)))
18

I’ll leave it as an exercise to you to have it as a standalone script in the project. I seem to have lost interest in it in its current form. Sorry. I’ll ditch the project and create another one for more general age calculations that would help me to remember my entire family’s birthdays. That’s the plan.

I’d like to thank Stuart and Sean for the enormous oversimplification of the development efforts of mine – Stuart planted the idea of using the library Sean currently maintains. Not much was left to me!

What I was however concerned with was that the Clojure’s version was merely 1.2.1 (the latest version is 1.3.0).

$ lein repl
REPL started; server listening on localhost port 16924
user=> (clojure-version)
"1.2.1"

I have yet to figure out how to rise it one level up to 1.3.0 outside a project, but as I was looking at the source code of leiningen/repl.clj I ran across the environment setting LEIN_REPL_PORT that does a magic to set nREPL’s port to a given value.

jacek:~/oss
$ LEIN_REPL_PORT=8000 lein repl
REPL started; server listening on localhost port 8000
user=>

It’s also possible to use :repl-port in a lein project to have nREPL server listen to this port.

Although it’s not the answer for the initial question of mine, I enjoyed it very much

Delving into the sources deeper, I ended up at leiningen/core/main.clj in which I found the (exit) function. It appears to work in REPL just fine.

jacek:~/oss
$ LEIN_REPL_PORT=8000 lein repl
REPL started; server listening on localhost port 8000
user=> (exit)

And when I was about to leave the main issue of having Clojure 1.3.0 available in REPL for the other day, I decided to glance at lein shell script itself (I work with the 1.6.2 version). That seemed like a great idea! See the following snippet I took off the lein script.

CLOJURE_JAR="$HOME/.m2/repository/org/clojure/clojure/1.2.1/clojure-1.2.1.jar"
# apply context specific CLASSPATH entries
if [ -f .lein-classpath ]; then
    CLASSPATH="`cat .lein-classpath`:$CLASSPATH"
fi

I couldn’t have believed what I’d found! I created a .lein-classpath file with Clojure 1.3.0 jar’s path inside hoping I eventually have that version inside REPL.

$ cat .lein-classpath
$HOME/.m2/repository/org/clojure/clojure/1.3.0/clojure-1.3.0.jar

With the change, I had thought lein repl would’ve given me what I initially was looking for – Clojure 1.3.1 inside the REPL for a standalone lein repl session, but it was far from truth. It simply didn’t work out.

$ DEBUG=1 lein repl
$HOME/.m2/repository/org/clojure/clojure/1.3.0/clojure-1.3.0.jar::::::test/:src/:resources/:/Users/jacek/.lein/self-installs/leiningen-1.6.2-standalone.jar
/Users/jacek/.m2/repository/org/clojure/clojure/1.2.1/clojure-1.2.1.jar
REPL started; server listening on localhost port 9641
user=> (clojure-version)
"1.2.1"

Then I realized I’d need to fix the script to let me choose the version of Clojure. I introduced the following change.

CLOJURE_JAR=${CLOJURE_JAR:-"$HOME/.m2/repository/org/clojure/clojure/1.2.1/clojure-1.2.1.jar"}

Ran lein repl and…ouch, it didn’t work either.

$ CLOJURE_JAR=$HOME/.m2/repository/org/clojure/clojure/1.3.0/clojure-1.3.0.jar DEBUG=1 lein repl
$HOME/.m2/repository/org/clojure/clojure/1.3.0/clojure-1.3.0.jar::::::test/:src/:resources/:/Users/jacek/.lein/self-installs/leiningen-1.6.2-standalone.jar
/Users/jacek/.m2/repository/org/clojure/clojure/1.3.0/clojure-1.3.0.jar

Exception in thread "main" java.lang.RuntimeException: java.lang.NoSuchMethodError: clojure.lang.KeywordLookupSite.<init>(ILclojure/lang/Keyword;)V
     at clojure.lang.Util.runtimeException(Util.java:165)
     at clojure.lang.Compiler.eval(Compiler.java:6476)
     at clojure.lang.Compiler.eval(Compiler.java:6431)
     at clojure.core$eval.invoke(core.clj:2795)
     at clojure.main$eval_opt.invoke(main.clj:296)
     at clojure.main$initialize.invoke(main.clj:315)
     at clojure.main$script_opt.invoke(main.clj:339)
     at clojure.main$main.doInvoke(main.clj:426)
     at clojure.lang.RestFn.invoke(RestFn.java:457)
     at clojure.lang.Var.invoke(Var.java:413)
     at clojure.lang.AFn.applyToHelper(AFn.java:172)
     at clojure.lang.Var.applyTo(Var.java:518)
     at clojure.main.main(main.java:37)
Caused by: java.lang.NoSuchMethodError: clojure.lang.KeywordLookupSite.<init>(ILclojure/lang/Keyword;)V
     at leiningen.util.paths$native_arch_path.<clinit>(paths.clj:32)
     at leiningen.util.paths__init.load(Unknown Source)
     at leiningen.util.paths__init.<clinit>(Unknown Source)
     at java.lang.Class.forName0(Native Method)
...

Time to report an issue to lein’s JIRA and hope it gets some love from the developers of lein. Would you support it?

Ah, use DEBUG to see what’s happening under the covers of the lein script when it runs.

And we were running quizes where I was picking the countries and capitals so she could practise. It was quite a while when I was learning it – it brought so much fun. Until she seemed a little tired. Then we stopped and after a while started over. The often we did it, the sooner she became tired. Fun was turning into frustration very quickly.

After a day or two I came up with an idea to write an application in Clojure instead. She could learn quite differently and hopefully more effectively (they say it’s important to change the ways we learn with different tools and techniques being changed often). She’d benefit and so would I. I couldn’t believe I’d be working on something real!

It took me a couple of hours before I finished the work with the following sample application in Clojure. Would you mind sharing your thoughts about its strengths and weaknesses? I do know it’s way too far from being production ready, and can’t think of a better way to have it as such without your help. I’d appreciate it very much! So would my daughter, I believe.

(ns geo-tester-clojure.core
  (:use 1]))

;; can be changed by user
(def ^:dynamic *number-of-questions* 10)

(def countries-cities
  [{:country "Polska" :capital "Warszawa"}
   {:country "Dania" :capital "Kopenhaga"}
   {:country "Liechtenstein" :capital "Vaduz"}
   {:country "Bosnia i Hercegowina" :capital "Sarajewo"}])

(def score (atom 0))

(defn score-up []
  "correct answer"
  (swap! score inc))

(defn score-down []
  "incorrect answer"
  (swap! score dec))

(defn capital-correct? [{:keys [capital]} answer]
  (.equalsIgnoreCase capital answer))

(defn quiz []
  (let [qs (take *number-of-questions* (shuffle countries-cities))]
    (loop [qs qs]
      (when-not (empty? qs)
        (let [cc (first qs)]
          (print (format "Enter the capital of %s: " (capitalize (:country cc))))
          (flush)
          (let [answer (read-line)]
            (if (capital-correct? cc answer)
              (score-up)
              (score-down)))
          (recur (next qs))))))
  (println "RESULT:" @score))

(quiz)