About RubyLearning

RL offers online courses in Ruby programming, Git & GitHub, Shoes, JRuby and Sinatra. Since 2005, over 25,000 participants spread across 140+ countries have learned Ruby and other Ruby related timely topics. This has been possible due to the extensive support provided by the mentors of these courses. RL strives hard to improve the methodology and course content based on the extensive and critical feedback we receive. Thanks to YOU and people like Fabio Akita who make this possible. Our Alumni are our best ambassadors.

You kept asking for it and so here it is – the second batch of the intensive, online course that helps you get started with Clojure programming.

Acknowledgements

Our special thanks go to Rich Hickey for providing us with this exciting new language as well as Mark Volkmann from Object Computing, Inc. for generously giving us permission to use his articles as teaching material for this course.

What’s Clojure?

According to Wikipedia: “Clojure is a modern dialect of the Lisp programming language. It is a general-purpose language supporting interactive development that encourages a functional programming style, and simplifies multithreaded programming. Clojure runs on the Java Virtual Machine and the Common Language Runtime. Clojure honors the code-as-data philosophy and has a sophisticated Lisp macro system.”

Stuart Halloway in his Programming Clojure book says – “Clojure feels like a general-purpose language beamed back from the near future. Its support for functional programming and software trans-actional memory is well beyond current practice and is well suited for multicore hardware. At the same time, Clojure is well grounded in the past and the present. It brings together Lisp and the Java Virtual Machine. Lisp brings wisdom spanning most of the history of programming, and Java brings the robustness, extensive libraries, and tooling of the dominant platform available today.”

What Will I Learn?

In this course, you will learn the essential features of Clojure that you will end up using every day. The course topics are tentative and could change with the feedback received:

• Week 0 – Getting started (no exercises)
  • Getting started
  • REPL
  • Functional Programming
• Week 1 – The basics
  • Clojure Overview
  • Clojure Syntax
  • Bindings
  • Defining functions
  • Destructuring
• Week 2 – Data
  • Collections
  • StructMaps
  • Sequences
  • Concurrency
  • Reference Types
• Week 3 – Control Flow
  • Conditional Processing
  • Iteration
  • Recursion
  • Predicates
  • Input/Output
• Week 4 – Advanced topics and tying it all together
  • Namespaces
  • Metadata
  • Macros
  • Java Interoperability
  • AOT Compiling

Who’s It For?

Anyone with an intermediate programming experience. People who have no previous exposure to Lisp and/or Clojure can get up-to-speed with Clojure with these Clojure Notes.

Mentors

Michael Kohl

Michael Kohl (Twitter / blog) in his day job, works as a Ruby on Rails programmer for Tupalo.com in Vienna, Austria. Michael fell in love with Clojure on first sight sometime in early 2009, but unfortunately never seems to have as much time to work with it as he wants to and started being a mentor for RubyLearning.org in early 2009. His interests include mathematics, literature, travelling, foreign languages, chess and so much more that he really wishes he wouldn’t need to sleep.

Daniel Solano Gómez

Daniel Solano Gómez (Twitter / blog) is the founder of Sattvik Software & Technology Resources, a software development company based in Houston, Texas. He studied mathematics at the University of Texas at Austin, but he discovered his passion for programming and computers as a child. Daniel has been developing software professionally for over a decade, primarily with C++ and Java. He started learning about and developing with Clojure in late 2009.

Michał Marczyk

Michał Marczyk is a PhD student doing research in logic / universal algebra in Kraków, Poland, always trying to coerce the computer into proving his theorems for him. His programming background is predominantly in functional programming; mostly in Scheme, Haskell and Clojure, which is rapidly becoming his favourite language.

Anthony Simpson

Anthony Simpson (Twitter / Blog) is a young, ambitious programmer in Eldridge, Alabama. His first language having been Haskell, the majority of his time with programming has been with functional programming languages, most of which has been spent with Clojure. A language person, he enjoys learning about new languages and improvements they make on existing languages. Non-computer-related interests include, (roller)skating, all aspects of music, and hacking life.

Isaac Hodes

Isaac (Twitter / Blog) is a Math major studying just about anything he can get his hands on. He likes to program, cook, and read as much as possible in his spare time. Programming in Clojure is what he does on vacation; it’s that much fun.

Dates

The course starts on Monday, 4th Oct. 2010 and runs for a month.

How do I register?

• You first create an account on the site (see right-hand top corner of the RubyLearning.org site). An email will be sent to your registered email address. This email contains a link to confirm your account. Please click on that link.
• Once your registration has been confirmed, login to the site and enroll into the Clojure 101 course.
• Update your profile (with photo) and introduce yourself at the Course Social Forum.

Course Fees

The course fee is US$ 5 per participant. The course fee goes towards maintaining RubyLearning and helps provide quality content to you.

Hurry, registrations have started.

At the end of this course you should have all the knowledge to explore the wonderful world of Clojure on your own.

Many of you wrote in asking for details on how the course works. Here are some details:

Important:

Once the course starts, you can login and start with the lessons any day and time and post your queries in the forum under the relevant lessons. Someone shall always be there to answer them. Just to set the expectations correctly, there is no real-time ‘webcasting’.

Methodology:

• The Mentors shall give you URL’s of pages and sometimes some additional notes; you need to read through. Read the pre-class reading material at a convenient time of your choice – the dates may be specified only as a guideline. While reading, please make a note of all your doubts, queries, questions, clarifications, comments about the lesson and after you have completed all the pages, post these on the forum under the relevant lesson. There may be some questions that relate to something that has not been mentioned or discussed by the mentors thus far; you could post the same too. Please remember that with every post, do mention the operating system of your computer.
• The mentor shall highlight the important points that you need to remember for that week’s session.
• There could be exercises for that week. Please do them.
• Participate in the forum for asking and answering questions or starting discussions. Share knowledge, and exchange ideas amongst yourselves during the course period. Participants are strongly encouraged to post technical questions, interesting articles, tools, sample programs or anything that is relevant to the class / lesson. Please do not post a simple "Thank you" note or "Hello" message to the forum. This forum is subscribed by several hundred people, so please be aware that these messages are considered as noises by many people.

Outline of Work Expectations:

1. The course starts on a Monday and the new course material will be available every Monday.
2. Most of the weeks, you will have exercises to solve. These are there to help you assimilate whatever you have learned till then.
3. Some weeks may have some mid-week additional assignments / food for thought articles / programs
4. Above all, do participate in the relevant forums. Past participants will confirm that they learned the best by active participation.

Some Commonly Asked Questions

• Qs. Is there any specific time when I need to be online?
  Ans. No. You need not be online at a specific time of the day.
• Qs. Is it important for me to participate in the course forums?
  Ans. YES. You must Participate in the forum(s) for asking and answering questions or starting discussions. Share knowledge, and exchange ideas amongst yourselves (participants) during the course period. Participants are strongly encouraged to post technical questions, interesting articles, tools, sample programs or anything that is relevant to the class / lesson. Past participants will confirm that they learned the best by active participation.
• Qs. How much time do I need to spend online for a course, in a day?
  Ans. This will vary from person to person. All depends upon your comfort level and the amount of time you want to spend on a particular lesson or task.
• Qs. Is there any specific set time for feedback (e.g., any mentor responds to me within 24 hours?)
  Ans. Normally somebody should answer your query / question within 24 – 48 hours.
• Qs. What happens if nobody answers my questions / queries?
  Ans. Normally, that will not happen. In case you feel that your question / query is not answered, then please post the same in the thread – “Any UnAnswered Questions / Queries”.
• Qs. What happens to the class (or forums) after a course is over? Can you keep it open for a few more days so that students can complete and discuss too?
  Ans. The course and its forum is open for a month after the last day of the course.

Remember, the idea is to have fun learning Clojure.

Programming Challenge for Newbies in Clojure and Python too?

RubyLearning has been conducting the monthly Ruby Programming Challenge for Newbies for over a year now and so far 12 challenges have been completed. The 13th challenge is in progress. All this was possible due to the extensive support we got from Rubyists across the world. Also, you all indicated that we continue with these challenges in the months to come.

Recently, my colleague Dhananjay Nene posted a Python based solution to the 13th Ruby challenge. While discussing the solution it struck me that it would help Clojure and Python Newbies, if we opened up these challenges in these languages too. Dhananjay and some of my Clojure colleagues are interested in evaluating the submitted solutions in Clojure and Python and maybe we could start the challenges from Oct. 2010.

Clojure and Python enthusiasts – interested? What Do you Think? What is Your Opinion? Please share in the comments below.

3rd Sept. Thanks for the very encouraging response. Based on the feedback received so far, we have decided the following:

• We will start the challenges for Clojure, Python and Ruby from 1st Oct. 2010. We will call these “Programming Challenge for Newbies” and host it on this blog till end Dec. 2010. If the response is encouraging, we can host the challenges on different domains.
• We will have separate panels to evaluate the solutions. One each for Clojure, Python and Ruby.
• We will keep separate prizes for the 3 languages (and hopefully would find some sponsors).
• The challenge problem setters (fixed till Dec. 2010) would be told that the problem should be solvable in all languages and specifically Clojure, Python and Ruby. This means that the problem setter should not set a problem that needs to be solved by some specific language feature.

Introducing an intensive, online course for beginners that helps you get started with Clojure programming.

What’s Clojure?

According to Wikipedia: “Clojure is a modern dialect of the Lisp programming language. It is a general-purpose language supporting interactive development that encourages a functional programming style, and simplifies multithreaded programming. Clojure runs on the Java Virtual Machine and the Common Language Runtime. Clojure honors the code-as-data philosophy and has a sophisticated Lisp macro system.”

Stuart Halloway in his Programming Clojure book says – “Clojure feels like a general-purpose language beamed back from the near future. Its support for functional programming and software trans-actional memory is well beyond current practice and is well suited for multicore hardware. At the same time, Clojure is well grounded in the past and the present. It brings together Lisp and the Java Virtual Machine. Lisp brings wisdom spanning most of the history of programming, and Java brings the robustness, extensive libraries, and tooling of the dominant platform available today.”

Antonio Cangiano says: “Clojure has three main advantages over Ruby:”

1. It’s much faster than Ruby, which makes it a better choice for intensive processing.
2. It greatly simplifies concurrent programming, making the language more future-proof as hardware manufacturers continue to produce processors with more CPU cores.
3. Clojure emphasizes functional programming and tries to minimize side effects.

What Will I Learn?

In this introductory course, you will learn the essential features of Clojure that you will end up using every day.

Who’s It For?

An absolute beginner in Lisp and / or Clojure but with some experience in other programming languages.

Mentor

Michael Kohl

Michael Kohl (Twitter / blog) in his day job, works as a Ruby on Rails programmer for Tupalo.com in Vienna, Austria. Michael fell in love with Clojure on first sight sometime in early 2009, but unfortunately never seems to have as much time to work with it as he wants to and started being a mentor for RubyLearning.org in early 2009. His interests include mathematics, literature, travelling, foreign languages, chess and so much more that he really wishes he wouldn’t need to sleep.

Dates

The course starts on Monday, 13th Sept. 2010 and runs for a week.

Course Fees

The course fee is US$ 5 and the entire course fee will be donated to the Clojure project.

Hurry, registrations have started.

At the end of this course you should have all the knowledge to explore the wonderful world of Clojure on your own.

How do I register?

You first need to register on the site and then enroll into the course.

Note: We are planning for an advanced course “Clojure 101″ around 2nd Oct. 2010. Watch out for an announcement. In the meantime you can read about the first batch of the Clojure 101 course.

Many of you wrote in asking for details on how the course works. Here are some details:

Important:

Once the course starts, you can login and start with the lessons any day and time and post your queries in the forum under the relevant lessons. Someone shall always be there to answer them. Just to set the expectations correctly, there is no real-time ‘webcasting’.

Methodology:

• The Mentors shall give you URL’s of pages and sometimes some additional notes; you need to read through. Read the pre-class reading material at a convenient time of your choice – the dates may be specified only as a guideline. While reading, please make a note of all your doubts, queries, questions, clarifications, comments about the lesson and after you have completed all the pages, post these on the forum under the relevant lesson. There may be some questions that relate to something that has not been mentioned or discussed by the mentors thus far; you could post the same too. Please remember that with every post, do mention the operating system of your computer.
• The mentor shall highlight the important points that you need to remember for that day’s session.
• There could be exercises every day. Please do them.
• Participate in the forum for asking and answering questions or starting discussions. Share knowledge, and exchange ideas amongst yourselves during the course period. Participants are strongly encouraged to post technical questions, interesting articles, tools, sample programs or anything that is relevant to the class / lesson. Please do not post a simple "Thank you" note or "Hello" message to the forum. This forum is subscribed by several people, so please be aware that these messages are considered as noises by many people.

Outline of Work Expectations:

1. Most of the days, you will have exercises to solve. These are there to help you assimilate whatever you have learned till then.
2. Some days may have some additional assignments / food for thought articles / programs
3. Above all, do participate in the relevant forums. Past participants will confirm that they learned the best by active participation.

Some Commonly Asked Questions

• Qs. Is there any specific time when I need to be online?
  Ans. No. You need not be online at a specific time of the day.
• Qs. Is it important for me to participate in the course forums?
  Ans. YES. You must Participate in the forum(s) for asking and answering questions or starting discussions. Share knowledge, and exchange ideas amongst yourselves (participants) during the course period. Participants are strongly encouraged to post technical questions, interesting articles, tools, sample programs or anything that is relevant to the class / lesson. Past participants will confirm that they learned the best by active participation.
• Qs. How much time do I need to spend online for a course, in a day?
  Ans. This will vary from person to person. All depends upon your comfort level and the amount of time you want to spend on a particular lesson or task.
• Qs. Is there any specific set time for feedback (e.g., any mentor responds to me within 24 hours?)
  Ans. Normally somebody should answer your query / question within 24 hours.
• Qs. What happens if nobody answers my questions / queries?
  Ans. Normally, that will not happen. In case you feel that your question / query is not answered, then please post the same in the thread – “Any UnAnswered Questions / Queries”.
• Qs. What happens to the class (or forums) after a course is over? Can you keep it open for a few more days so that students can complete and discuss too?
  Ans. The course and its forum is open for a month after the last day of the course.
• Qs. How do I quit from a course?
  Ans. We wouldn’t like that to happen. However, in case you want to ‘quit’ from a course or for some reason want to un-subscribe, kindly message Satish Talim or email him at satish.talim [at] gmail [dot] com

Remember, the idea is to have fun learning Clojure.

In this brief interview, Satish Talim of RubyLearning talks to Andrew Boekhoff, author of CongoMongo, a toolkit for using MongoDB with Clojure.

Satish>> Welcome Andrew and thanks for taking out time to share your thoughts. What programming languages have you used seriously?

Andrew>> Seriously: Ruby and Clojure. Less Seriously: C, C++, Java and now: Haskell, Scheme.

Satish>> Why and when did you decide to start working on Clojure?

Andrew>> I’ve been using Clojure for a little over a year. I had read Paul Graham’s essays, so I wanted to try a lisp dialect. I also wanted to learn what functional programming was all about. Then I watched Rich Hickey’s presentations on Clojure and by that point I was pretty much sold.

Satish>> Could you name three features of Clojure that you like the most, as compared to other languages? Why?

Andrew>>

1. Immutability: Using immutable locals and data structures as the default eliminates a huge class of potential errors. I’ve never written as much code that worked on the first try in any other language. Concurrency is often mentioned as a great benefit from pervasive immutability — and it certainly is — but for me, the net reduction in complexity is what I love most.
2. It’s a Lisp: It has Macros: Whether its for shearing off boiler plate, or embedding a parser for an internal DSL, the ability to easily extend the syntax of the language is a uniquely expressive trait of the lisp family.
3. The immense practicality of the JVM: By being hosted on the JVM, Clojure comes with batteries-included and can be deployed anywhere that Java can (almost anywhere).

Satish>> You have written a Clojure wrapper (congomongo) for the mongo-db java api. Can you tell us more about this wrapper? Also, why did you target MongoDB?

Andrew>> I really like working with MongoDB. The combination of schema-less document storage and ad-hoc queries is fantastic. The JSON format fits Clojure’s data structures well, and the mongo-java-driver is high quality and maintained. Congomongo is fairly light-weight — its main goal is to make interacting with the database from Clojure convenient and idiomatic.

Thank you Andrew. In case you have any queries and/or questions, kindly post your questions here (as comments to this blog post) and Andrew would be glad to answer.

RubyLearning wrote to a lot of experts, gathering their best tips on Clojure. The tips are still coming in, but here are some to get you started with. Feel free to add your own tips in the comments section or send the same to satishtalim [at] gmail.com. Enjoy!

Antonio Cangiano

Find him on Twitter. His Blog.

When learning a new programming language, I find Project Euler to be an invaluable source of self-contained, increasingly more challenging exercises. By solving these mathematical problems in your language of choice, you’ll get some degree of exposure and familiarity with that language before tackling more complex, real world tasks.

When you solve a problem, you gain access to a forum where you can compare your implementation with those of other people who may have used the same language as you, or a different one. Normally there is a variety of common (and not so common) languages used by fellow participants.

Through the forum you’ll learn about more efficient algorithms and clever tricks, but above all you’ll get to see different ways to solve the same problem. It’s not hard to spot clean, concise, and idiomatic implementations and as a result end up learning more about the language you used.

Unfortunately for Clojure beginners, the threads in the forum for many of the initial problems were closed a long time ago. In practice, this means that you can usually read solutions implemented in many established programming languages, including Ruby and Haskell, but you won’t find solutions in Clojure for most of the problems (Clojure is after all much newer).

Thankfully, a wiki which collects many solutions in Clojure exists. If you solve the problems first on your own, you can then use this resource to compare your approach with those of other Clojure programmers. You may discover that there is a better, more idiomatic way of solving a given problem.

In short, use Project Euler and the Clojure Euler wiki if you want to get some experience with Clojure’s syntax and fundamental concepts, which you may have only read about in books or online tutorials.

---

Baishampayan Ghose

Find him on Twitter. His GitHub a/c.

It’s hard to pin point a few good tips because Clojure can do so many things in very nice and ingenious ways, that it’s not even funny. Anyway, here are a few:

Tip #1: Sort a map on multiple keys:

;;; Tip #1
;;; A vector of maps
(def some-maps [{:x 1 :y 2} {:x 2 :y 1} {:x 1 :y 4} {:x 2 :y 8}])

;;; Sort the maps first on :x and then on :y

(defn sort-maps-by
  "Sort a sequence of maps (ms) on multiple keys (ks)"
  [ms ks]
  (sort-by #(vec (map % ks)) ms))

;;; (sort-maps-by some-maps [:x :y])
;;; output> ({:x 1, :y 2} {:x 1, :y 4} {:x 2, :y 1} {:x 2, :y 8})

Tip #2: When dealing with infinite sequences on the REPL, you can set the number of items to be printed:

;;; Tip #2
;;; When you type something like (iterate inc 1) on the REPL (or any
;;; kind of infinite, lazy sequence) the REPL will try to evaluate the
;;; whole thing and will never finish. One way to print some parts of
;;; an infinite sequence on the REPL is to do this on the REPL and
;;; then try to print the sequence -
;;; (set! *print-length* 10)
;;; (iterate inc 1)
;;; Which will only print the first 10 items of the above infinite
;;; sequence -
;;; (1 2 3 4 5 6 7 8 9 10 ...)
;;; There is also *print-level* which can be used to determine how
;;; nested/recursive data-structures are printed on the REPL

Tip #3: Use of the -> & ->> threading macros:

The -> & ->> threading macros are very useful to sometimes untangle nested function calls. The -> macro takes a bunch of ‘forms’ and ‘threads them’ into each other by inserting every form as the second item of the next form and so on. So, (->> a (b c) (d e f) (g h)) becomes (g (d (b a c) e f) h). ->> is similar but it puts the form as the last item of the next form. (->> a (b c) (d e f) (g h)) then becomes (g h (d e f (b c a))).

(ns tips
  ;; requires clojure 1.2 if you are on 1.1.x, use this instead
  ;; (:require [clojure.contrib.duck-streams :as io])
  (:require [clojure.contrib.io :as io]))

;;; Tip #3
;;; Use of the -> & ->> threading macros.
(defn word-freq
  "Calculate a frequency map of words in a text file."
  [f]
  (take 20 (->> f
                io/read-lines
                (mapcat (fn [l] (map #(.toLowerCase %) (re-seq #"\w+" l))))
                (remove #{"the" "and" "of" "to" "a" "i" "it" "in" "or" "is"})
                (reduce #(assoc %1 %2 (inc (%1 %2 0))) {})
                (sort-by (comp - val)))))

;;; Run it like this (word-freq "/path/to/file.txt")

---

Brian Carper

Find him on Twitter. His Blog.

“Named” or “keyword” arguments for functions have some benefits over positional arguments:

1. You can specify arguments in any order.
2. The arguments are named explicitly, resulting in less room for error compared to positional arguments, where it’s easy to transpose two arguments in the list.
3. Your function can easily provide default argument values.

For a function that takes only one or two arguments, keyword arguments might be overkill. But the benefits of keyword arguments quickly become more apparent the more argumentss your function accepts.

Clojure doesn’t have canonical support for keyword arguments. But there are a couple of ways you can achieve the same result.

The first is simply to force the user to pass a hash-map explicitly.

(defn named-args-1 [foo argmap]
 (println "foo:" foo
          "bar:" (:bar argmap 0)
          "baz:" (:baz argmap 0))
 (println "bar-given?" (contains? argmap :bar)
          "baz-given?" (contains? argmap :baz)))

user> (named-args-1 1 {:baz 2})
foo: 1 bar: 0 baz: 2
bar-given? false baz-given? true

But wrapping arguments in braces is arguably an unnecessary burden on users of your code. A better way is to use destructuring to allow the user to “flatten” the map:

(defn named-args-2 [foo & args]
 (let [argmap (apply hash-map args)
       {:keys [bar baz]
        :or   {bar 0 baz 0}} argmap]
   (println "foo:" foo
            "bar:" bar
            "baz:" baz)
   (println "bar-given?" (contains? argmap :bar)
            "baz-given?" (contains? argmap :baz))))

user> (named-args-2 1 :baz 2)
foo: 1 bar: 0 baz: 2
bar-given? false baz-given? true

This is OK for the user, but verbose for the function-writer. And the argument list for the function is specified as “args”, giving the user no clue as to what keys are expected or legal.

As of recent releases of Clojure, you can do the destructuring right in the function’s argument list, leading to this version:

(defn named-args-3 [foo & {:keys [bar baz]
                          :or   {bar 0 baz 0}
                          :as   argmap}]
 (println "foo:" foo
          "bar:" bar
          "baz:" baz)
 (println "bar-given?" (contains? argmap :bar)
          "baz-given?" (contains? argmap :baz)))

user> (named-args-3 1 :baz 2)
foo: 1 bar: 0 baz: 2
bar-given? false baz-given? true

It’s also possible to roll your own macro to do keyword arguments. See clojure.contrib.def/defnk, for example.

---

Craig Andera

Find him on Twitter. His Blog.

I have two. The first one I stole from Mike Fogus: to use “,,,” as a placeholder in the -> and ->> macros. Since commas are whitespace, they can be used as markers to indicate how the expressions flow through the threading macros. So, for instance, you can write:

(->>
 (iterate inc 1)
 (map #(* 5 %) ,,,)
 (filter odd? ,,,))

and the commas indicate “the previous expression will be inserted here”.

It’s not something you should put in production code, but I found it enormously helpful in “getting” the -> and ->> macros. Honestly, I only had to write it out this way once or twice before it clicked with me and I stopped using the commas altogether.

The other tip I have, has to do with understanding when to use map, filter, and reduce. These three functions are where an enormous amount of Clojure’s power comes from, but I find that beginners (such as myself) sometimes have a hard time selecting which one – or which combination – to use. What I’ve found is that it’s helpful to think of these in terms of what you *have* and what you *need*:

• If you *have* a sequence of length n and you *need* a sequence of length n, use map.
• If you *have* a sequence of length n and you *need* a shorter sequence, use filter.
• If you *have* a sequence of length n and you *need* a scalar, use reduce.

It seems pretty obvious when stated like that, but it has been helpful to me on occasion when I start to get lost in how to express a particular algorithm.

---

Meikel Brandmeyer

Find him on Twitter. His BitBucket Id.

Here is my tip on atoms.

Clojure provides a lot of facilities to tackle the complexity of concurrent programming. But still you have to understand the semantics of the underlying facilities. One of these are refs, which allow coordinated access to several different entities at once. However, their use inflicts quite a bit of ceremony. You have to invoke the STM machinery whenever you want to write to a ref or want a consistent snapshot of several refs. Also your transaction is rolled back should a surrounding transaction retry. This is not always what you want.

In such cases, it is interesting to use an atom. They are cheaper in terms of overhead and don’t interact with the STM. So the retry of a surrounding transaction doesn’t affect them. However they are uncoordinated: you can’t safely update multiple atoms at once.

What is not so well known, is the fact, that refs also coordinate several accesses to the *same* ref. Again, this does *not* work well with atoms. Consider a cache, eg. for a memoized function.

(defn memoize
 [f]
 (let [cache (atom {})]
   (fn [& args]
     (when-not (contains? @cache args)
       (swap! cache assoc args (apply f args)))
     (get @cache args))))

This code uses an atom and clojure datastructures, so we have no problems with concurrency, right? Wrong! There are plenty of race conditions between the different calls to contains?, swap! and get. In the example, the worst thing that can happen is that we compute the value of the function call several times. This can already be quite annoying if the call is expensive in computation time and/or resources. But consider a more involved cache implementation which could also remove entries from the cache. Then the call to contains? could see the value, but when we call get it might already be removed.

The problem is, that we access the atom’s contents several times and this is not coordinated. Contrary to refs where we could call ensure to – well – ensure that the ref doesn’t change under our hands.

How to solve this problem? Well, the problem is that we touch the atom several times. So the solution is to touch the atom only once!

(defn memoize
 [f]
 (let [cache  (atom {})
       update (fn [state args]
                (if-not (contains? state args)
                  (assoc state args (apply f args))
                  state))]
   (fn [& args]
     (get (swap! cache update args) args))))

Here we do the contains check and update in one function which will see a consistent view of the cache state. Note that we also use the return value of the swap!. Otherwise we would again have to access to the atom several times!

So while Clojure provides a lot of tools to tackle the problems of a concurrent world, you still have to understand what the semantics of the different tools are. And even then you have to carefully reason about your code. How it behaves. Where race conditions might hide. Life is not easy.

Note: There are other problems to the above problem. Eg. doing expensive work – namely calling f – in a swap!. Please read Meikel’s blog post on memoize where even more such considerations are taken into account.

---

Michael Fogus

Find him on Twitter. His book The Joy of Clojure.

Many macros that I write start exactly the same way:

   (defmacro a-macro [& forms]
     `'~forms)

Then it proceeds to be transformed into a pipeline where each piece does a gradual transformation of forms:

   (defn do-something [forms]
     (frobnicate forms))

   (defn do-something-else [forms]
     (moidilize forms))

   (defmacro a-macro [& forms]
     (let [forms (do-something forms)
           forms (do-something-else forms)])
     `'~forms)

This makes it easy to see the transformations occurring at each step, keeps my macros small, and allows me to put error handling in each of the transformation functions for compile-time exceptions.

Although this is all pretty arcane as I try really really hard to avoid writing macros else I get beaten.

---

Michael Kohl

Find him on Twitter. His Blog.

My tip would be the Clojure reader macro #_ which completely ignores the next form. From the docs:

“The form following #_ is completely skipped by the reader. (This is a more complete removal than the comment macro which yields nil).”

This can be immensely useful while debugging.

---

Nurullah Akkaya

Find him on Twitter. His Blog.

My tip would be on destructuring, which allows you to pull apart data structures into local bindings.

     (let [[x y] [1 2]]
       x)
     ;;user=> 1

     (let [[a b c] "abc"]
       c)
     ;;user=> \c

     (let [[[x1 y1][x2 y2]] [[1 2] [3 4]]]
       [x1 y1 x2 y2])
     ;;user=> [1 2 3 4]

Besides destructuring sequential things (vectors, lists, seqs, strings, arrays, or anything that supports nth), you can destructure maps as well:

     (let [{key1 :key1 key2 :key2} {:key1 5 :key2 6}]
       [key1 key2])
     ;;user=> [5 6]

     (let [{[x1 y1] :player1 [x2 y2] :player2} {:player1 [5 6] :player2 [9 9]}]
       [x1 y1 x2 y2])
     ;;user=> [5 6 9 9]

Most of the time, your local variables has the same names as the keywords, Clojure provides a shortcut that saves you from typing binding x keyword :x over and over again:

     (let [{:keys [key1 key2]} {:key1 5 :key2 6}]
            [key1 key2])
     ;;user=> [5 6]

For more on destructuring, checkout the documentation.

---

Ramakrishnan Muthukrishnan

Find him on Twitter. His GitHub Id.

Tip #1:

If you have a sequence and want to remove duplicates, there are (atleast) two ways to do it:

(vec (into #{} [1 2 2 3 4 5])) ; => [1 2 3 4 5]

or

(distinct [1 2 2 3 4 5]) ; => [1 2 3 4 5]

The second one is preferred.

Tip #2:

In a function, if you have a list of parameters, you can do the following:

(defn foo [x & xs]
 (...))

The same can be done in anonymous functions too. What if you are using the abbreviated form (reader macro form) of an anonymous function? You can still use it by using the “%&” to denote the rest of the argument as a list. One example of the use of this form is shown here.

Tip #3: I echo Craig Andera’s opinions on map, filter and reduce. It is extremely important to master these three constructs. Especially, the way reduce can be used with hash-maps.

Tip #4: If you want to have default values for some of the input parameters, one way is to define functions of diferent arity.

(defn foo
 ([] (foo "bar"))
 ([s] (........)))

Here, when ‘foo’ is called without any arguments, we assume a default value of “bar”, a string as argument to the function and call foo with that argument.

---

Stuart Sierra

Find him on Twitter. His Blog.

Well, I’ve said this before, but it bears saying again: Don’t write a macro where a function will do. Functions are more flexible: they can be composed and passed as values. Do not use macros solely to make the syntax “prettier.”

---

Do you like these tips? We are eager to know your reactions as comments to this post.