tag:blogger.com,1999:blog-3908276794795362019.post-2045914209941115115 2012-05-30T14:00:10+00:00

Literate Programming in Clojure

1 Literate programming in clojure using org-mode babel

1 Literate programming in clojure using org-mode babel

In this post I'll first show a double setup of org-mode babel-clojure with both inferior-lisp and slime, and then I will show how to use org-babel-clojure for literate programming.

1.1 Literate programming

Who doesn't know this situation: You have to modify someone others code but you have no clue what this code should do. Searching around the (often barely documentation) doesn't help much either, because it is often not clear what intention the author had with the code, or why he implemented it that way. Literate programming does not only help others reading your code, but it helps you as well,because

writing down your intention and explaining it makes it easier for you to code it
it helps you to be clear about your design decisions
writing it down intented to be read by others makes you to automatically write code of better quality

In Literate programming, you mix the explanation of the programm and the source code in one file. The source code can be automatically extracted. This is called tangling. It is also possible to evaluate the code while you are in the document.

1.2 Org-mode-babel

Babel is a part of org-mode that is a full featured literate programming program. Being part of org-mode, it is also able to be exported into a variety of formats including latex and html. I am using it to write my series of 'Porting PAIP to clojure'. Each blog-post is just a .org file which gets exported to html and uploaded on blogger. Here is the setup:

1.2.1 Setting up org-mode-babel with clojure

Fortunately, clojure is a supported language of org-mode, but it's documentation is outdated. So add following to your .emacs file:

(require 'ob)
(require 'ob-tangle)
(add-to-list 'org-babel-tangle-lang-exts '("clojure" . "clj"))

(org-babel-do-load-languages
 'org-babel-load-languages
 '((emacs-lisp . t)
   (clojure . t)))
(require 'ob-clojure)

(defun org-babel-execute:clojure (body params)
  "Evaluate a block of Clojure code with Babel."
  (concat "=> "
          (if (fboundp 'slime-eval)
              (slime-eval `(swank:interactive-eval-region ,body))
           (if (fboundp 'lisp-eval-string)
             (lisp-eval-string body)
              (error "You have to start a clojure repl first!")))))

(setq org-src-fontify-natively t)
(setq org-confirm-babel-evaluate nil)
(setq org-export-babel-evaluate nil)
(setq org-src-window-setup 'current-window)
(setq inferior-lisp-program "lein repl")

(I assume you have a recent org-mode installed) It will work with either inferior lisp using lein repl, which has the advantage that you can run it without a project.clj file, or with M-x clojure-jack-in, which gives you the goddies of slime with clojure.
I have also written a few lines to make the exported html look better and defined a skeleton to quickly insert the first lines in the .org file. If you type C-S-f4, you will be prompted for the title and the content of the skeleton will be inserted.

  (define-skeleton org-skeleton
  "Header info for a emacs-org file."
  "Title: "
  "#+TITLE:" str " \n"
  "#+AUTHOR: Maik Schünemann\n"
  "#+email: maikschuenemann@gmail.com\n"
  "#+STARTUP:showall\n"
  "-----"
 )
(global-set-key [C-S-f4] 'org-skeleton)

(setq org-export-html-style-extra "<style type=\"text/css\">pre {\n    border: 1pt solid #AEBDCC;\n   color:white;\n background-color: #000000;\n     padding: 5pt;\n font-family: courier, monospace;\n        font-size: 90%;\n        overflow:auto;\n  } </style>")

1.2.2 Interacting with clojure code.

Start a repl first. Either via M-x run-lisp or with M-x clojure-jack-in. Note, if you use the former, the result of the code won't get inserted in the .org file after evaluation.
To write some clojure-code, type the following (may be good to define a kbd-macro to speed this up)

#+begin_src clojure :results output :exports both
(def six (+ 1 2 3))
#+end_src

If you place your cursor between the begin_src and end_src and type C-c C-c, you will see the following:

#+begin_src clojure :results output :exports both
 (def six (+ 1 2 3))
 #+end_src

#+RESULTS:
: => #'user/six

Note that the code got evaluated and is now defined in the repl. So if you evaluate the following (either in the file, or in the repl, you will see:

#+begin_src clojure :results output :exports both
six
#+end_src 

#+RESULTS:
: => 6

So you loose nothing of the interactive development you love when coding clojure.

1.2.3 Exporting to html

When you are done, you can export the file to html by typing C-c C-e h or C-c C-e b to see the exported html in your standart browser. If you want the source code to be colorized like you see it in clojure-mode, you need to install the htmlize package (via elpa) The clojure code shown above will export to the following:

(def six (+ 1 2 3))

=> #'user/six

Cool, nicely colored clojure code in your html-documentation or your blog-post. So This should be enough to get you started using org-mode-babel with clojure for Literate Programming. It is interactive like writing normal clojure code and it helps you to think more clearly about your code.

1.3 the org-file

Here is the org-file that you see right now:

#+TITLE:Literate Programming in Clojure
#+AUTHOR: Maik Schünemann
#+email: maikschuenemann@gmail.com
#+STARTUP:showall
-----
* Literate programming in clojure using org-mode babel
In my previous post ... I showed a setup of clojure with org-mode babel using inferior lisp.
In this post I'll first show a double setup with both inferior-lisp and slime, and then I will
show how to use org-babel-clojure for literate programming.
** Literate programming
Who doesn't know this situation:
You have to modify someone others code but you have no clue what this code should do. Searching
around the (often barely documentation) doesn't help much either, because it is often not clear
what intention the author had with the code, or why he implemented it that way.
[[http://de.wikipedia.org/wiki/Literate_programming][Literate programming]] does not only help others reading your code, but it helps you as well,because
- writing down your intention and explaining it makes it easier for you to code it
- it helps you to be clear about your design decisions
- writing it down intented to be read by others makes you to automatically write code of better quality
In Literate programming, you mix the explanation of the programm and the source code in one file.
The source code can be automatically extracted. This is called tangling. It is also possible to evaluate
the code while you are in the document.
** Org-mode-babel
[[http://orgmode.org/worg/org-contrib/babel/][Babel]] is a part of [[http://orgmode.org/][org-mode]] that is a full featured literate programming program. Being part of org-mode,
it is also able to be exported into a variety of formats including latex and html. I am using it to write
my series of 'Porting PAIP to clojure'. Each blog-post is just a .org file which gets exported to html and
uploaded on blogger. Here is the setup:
*** Setting up org-mode-babel with clojure
Fortunately, clojure is a supported language of org-mode, but it's documentation is outdated. So add following
to your .emacs file:
#+begin_src elisp
(require 'ob)
(require 'ob-tangle)
(add-to-list 'org-babel-tangle-lang-exts '("clojure" . "clj"))

(org-babel-do-load-languages
'org-babel-load-languages
'((emacs-lisp . t)
(clojure . t)))
(require 'ob-clojure)

(defun org-babel-execute:clojure (body params)
"Evaluate a block of Clojure code with Babel."
(concat "=> "
(if (fboundp 'slime-eval)
(slime-eval `(swank:interactive-eval-region ,body))
(if (fboundp 'lisp-eval-string)
(lisp-eval-string body)
(error "You have to start a clojure repl first!")))))

(setq org-src-fontify-natively t)
(setq org-confirm-babel-evaluate nil)
(setq org-export-babel-evaluate nil)
(setq org-src-window-setup 'current-window)
(setq inferior-lisp-program "lein repl")
#+end_src
(I assume you have a recent org-mode installed)
It will work with either inferior lisp using lein repl, which has the advantage that you can run it without
a project.clj file, or with M-x clojure-jack-in, which gives you the goddies of slime with clojure.

I have also written a few lines to make the exported html look better and defined a skeleton to quickly insert
the first lines in the .org file. If you type C-S-f4, you will be prompted for the title and the content of the
skeleton will be inserted.
#+begin_src elisp
(define-skeleton org-skeleton
"Header info for a emacs-org file."
"Title: "
"#+TITLE:" str " \n"
"#+AUTHOR: Maik Schünemann\n"
"#+email: maikschuenemann@gmail.com\n"
"#+STARTUP:showall\n"
"-----"
)
(global-set-key [C-S-f4] 'org-skeleton)

(setq org-export-html-style-extra "<style type=\"text/css\">pre {\n border: 1pt solid #AEBDCC;\n color:white;\n background-color: #000000;\n padding: 5pt;\n font-family: courier, monospace;\n font-size: 90%;\n overflow:auto;\n } </style>")
#+end_src

*** Interacting with clojure code.
Start a repl first. Either via M-x run-lisp or with M-x clojure-jack-in. Note, if you use the former, the
result of the code won't get inserted in the .org file after evaluation.

To write some clojure-code, type the following (may be good to define a kbd-macro to speed this up)
#+begin_example
#+begin_src clojure :results output :exports both
(def six (+ 1 2 3))
#+end_src
#+end_example
If you place your cursor between the begin_src and end_src and type C-c C-c, you will see the following:
#+begin_example
#+begin_src clojure :results output :exports both
(def six (+ 1 2 3))
#+end_src

#+RESULTS:
: => #'user/six
#+end_example
Note that the code got evaluated and is now defined in the repl. So if you evaluate the following (either in
the file, or in the repl, you will see:
#+begin_example
#+begin_src clojure :results output :exports both
six
#+end_src

#+RESULTS:
: => 6
#+end_example
So you loose nothing of the interactive development you love when coding clojure.

*** Exporting to html
When you are done, you can export the file to html by typing C-c C-e h or C-c C-e b to see the exported
html in your standart browser.
If you want the source code to be colorized like you see it in clojure-mode, you need to install the
htmlize package (via elpa)
The clojure code shown above will export to the following:

#+begin_src clojure :results output :exports both
(def six (+ 1 2 3))
#+end_src

#+RESULTS:
: => #'user/six
Cool, nicely colored clojure code in your html-documentation or your blog-post.
So This should be enough to get you started using org-mode-babel with clojure for Literate Programming.
It is interactive like writing normal clojure code and it helps you to think more clearly about your code.

** the org-file
Here is the org-file that you see right now:
(leaving this part out to avoid infinite file size...)

Date: 2012-05-30T11:17+0200

Author: Maik Schünemann

Org version 7.8.09 with Emacs version 23

Validate XHTML 1.0

Maik Schünemann noreply@blogger.com http://kimavcrp.blogspot.com/search/label/clojure Exploring the programming world</h1> <p>2012-05-30T14:00:10+00:00</p> <br /><div id="content" style="font-family: Times, serif; font-size: 16px;"><h1 class="title" style="text-align: center;"> Literate Programming in Clojure</h1><hr /><div id="table-of-contents"><h2> Table of Contents</h2><div id="text-table-of-contents"><ul><li><a href="http://www.blogger.com/blogger.g?blogID=3908276794795362019#sec-1">1 Literate programming in clojure using org-mode babel</a><ul><li><a href="http://www.blogger.com/blogger.g?blogID=3908276794795362019#sec-1-1">1.1 Literate programming</a></li><li><a href="http://www.blogger.com/blogger.g?blogID=3908276794795362019#sec-1-2">1.2 Org-mode-babel</a><ul><li><a href="http://www.blogger.com/blogger.g?blogID=3908276794795362019#sec-1-2-1">1.2.1 Setting up org-mode-babel with clojure</a></li><li><a href="http://www.blogger.com/blogger.g?blogID=3908276794795362019#sec-1-2-2">1.2.2 Interacting with clojure code.</a></li><li><a href="http://www.blogger.com/blogger.g?blogID=3908276794795362019#sec-1-2-3">1.2.3 Exporting to html</a></li></ul></li><li><a href="http://www.blogger.com/blogger.g?blogID=3908276794795362019#sec-1-3">1.3 the org-file</a></li></ul></li></ul></div></div><div class="outline-2" id="outline-container-1"><h2 id="sec-1"> <span class="section-number-2">1</span> Literate programming in clojure using org-mode babel</h2><div class="outline-text-2" id="text-1">In this post I'll first show a double setup of org-mode babel-clojure with both inferior-lisp and slime, and then I will show how to use org-babel-clojure for literate programming.</div><div class="outline-3" id="outline-container-1-1"><h3 id="sec-1-1"> <span class="section-number-3">1.1</span> Literate programming</h3><div class="outline-text-3" id="text-1-1">Who doesn't know this situation: You have to modify someone others code but you have no clue what this code should do. Searching around the (often barely documentation) doesn't help much either, because it is often not clear what intention the author had with the code, or why he implemented it that way. <a href="http://de.wikipedia.org/wiki/Literate_programming">Literate programming</a> does not only help others reading your code, but it helps you as well,because<br /><ul><li>writing down your intention and explaining it makes it easier for you to code it</li><li>it helps you to be clear about your design decisions</li><li>writing it down intented to be read by others makes you to automatically write code of better quality</li></ul>In Literate programming, you mix the explanation of the programm and the source code in one file. The source code can be automatically extracted. This is called tangling. It is also possible to evaluate the code while you are in the document.</div></div><div class="outline-3" id="outline-container-1-2"><h3 id="sec-1-2"> <span class="section-number-3">1.2</span> Org-mode-babel</h3><div class="outline-text-3" id="text-1-2"><a href="http://orgmode.org/worg/org-contrib/babel/">Babel</a> is a part of <a href="http://orgmode.org/">org-mode</a> that is a full featured literate programming program. Being part of org-mode, it is also able to be exported into a variety of formats including latex and html. I am using it to write my series of 'Porting PAIP to clojure'. Each blog-post is just a .org file which gets exported to html and uploaded on blogger. Here is the setup:</div><div class="outline-4" id="outline-container-1-2-1"><h4 id="sec-1-2-1"> <span class="section-number-4">1.2.1</span> Setting up org-mode-babel with clojure</h4><div class="outline-text-4" id="text-1-2-1">Fortunately, clojure is a supported language of org-mode, but it's documentation is outdated. So add following to your .emacs file:<br /><pre class="src src-elisp" style="background-color: black; border: 1pt solid rgb(174, 189, 204); color: white; font-family: courier, monospace; font-size: 14px; overflow: auto; padding: 5pt;">(<span style="color: cyan;">require</span> '<span style="color: aquamarine;">ob</span>)<br />(<span style="color: cyan;">require</span> '<span style="color: aquamarine;">ob-tangle</span>)<br />(add-to-list 'org-babel-tangle-lang-exts '(<span style="color: lightsalmon;">"clojure"</span> . <span style="color: lightsalmon;">"clj"</span>))<br /><br />(org-babel-do-load-languages<br /> 'org-babel-load-languages<br /> '((emacs-lisp . t)<br /> (clojure . t)))<br />(<span style="color: cyan;">require</span> '<span style="color: aquamarine;">ob-clojure</span>)<br /><br />(<span style="color: cyan;">defun</span> <span style="color: lightskyblue;">org-babel-execute:clojure</span> (body params)<br /> <span style="color: lightsalmon;">"Evaluate a block of Clojure code with Babel."</span><br /> (concat <span style="color: lightsalmon;">"=> "</span><br /> (<span style="color: cyan;">if</span> (fboundp 'slime-eval)<br /> (slime-eval `(swank:interactive-eval-region ,body))<br /> (<span style="color: cyan;">if</span> (fboundp 'lisp-eval-string)<br /> (lisp-eval-string body)<br /> (<span style="color: pink; font-weight: bold;">error</span> <span style="color: lightsalmon;">"You have to start a clojure repl first!"</span>)))))<br /><br />(setq org-src-fontify-natively t)<br />(setq org-confirm-babel-evaluate nil)<br />(setq org-export-babel-evaluate nil)<br />(setq org-src-window-setup 'current-window)<br />(setq inferior-lisp-program <span style="color: lightsalmon;">"lein repl"</span>)<br /></pre>(I assume you have a recent org-mode installed) It will work with either inferior lisp using lein repl, which has the advantage that you can run it without a project.clj file, or with M-x clojure-jack-in, which gives you the goddies of slime with clojure.<br />I have also written a few lines to make the exported html look better and defined a skeleton to quickly insert the first lines in the .org file. If you type C-S-f4, you will be prompted for the title and the content of the skeleton will be inserted.<br /><pre class="src src-elisp" style="background-color: black; border: 1pt solid rgb(174, 189, 204); color: white; font-family: courier, monospace; font-size: 14px; overflow: auto; padding: 5pt;"> (<span style="color: cyan;">define-skeleton</span> <span style="color: lightskyblue;">org-skeleton</span><br /> <span style="color: lightsalmon;">"Header info for a emacs-org file."</span><br /> <span style="color: lightsalmon;">"Title: "</span><br /> <span style="color: lightsalmon;">"#+TITLE:"</span> str <span style="color: lightsalmon;">" \n"</span><br /> <span style="color: lightsalmon;">"#+AUTHOR: Maik Schünemann\n"</span><br /> <span style="color: lightsalmon;">"#+email: maikschuenemann@gmail.com\n"</span><br /> <span style="color: lightsalmon;">"#+STARTUP:showall\n"</span><br /> <span style="color: lightsalmon;">"-----"</span><br /> )<br />(global-set-key [C-S-f4] 'org-skeleton)<br /><br />(setq org-export-html-style-extra <span style="color: lightsalmon;">"<style type=\"text/css\">pre {\n border: 1pt solid #AEBDCC;\n color:white;\n background-color: #000000;\n padding: 5pt;\n font-family: courier, monospace;\n font-size: 90%;\n overflow:auto;\n } </style>"</span>)<br /></pre></div></div><div class="outline-4" id="outline-container-1-2-2"><h4 id="sec-1-2-2"> <span class="section-number-4">1.2.2</span> Interacting with clojure code.</h4><div class="outline-text-4" id="text-1-2-2">Start a repl first. Either via M-x run-lisp or with M-x clojure-jack-in. Note, if you use the former, the result of the code won't get inserted in the .org file after evaluation.<br />To write some clojure-code, type the following (may be good to define a kbd-macro to speed this up)<br /><pre class="example" style="background-color: black; border: 1pt solid rgb(174, 189, 204); color: white; font-family: courier, monospace; font-size: 14px; overflow: auto; padding: 5pt;">#+begin_src clojure :results output :exports both<br />(def six (+ 1 2 3))<br />#+end_src<br /></pre>If you place your cursor between the begin<sub>src</sub> and end<sub>src</sub> and type C-c C-c, you will see the following:<br /><pre class="example" style="background-color: black; border: 1pt solid rgb(174, 189, 204); color: white; font-family: courier, monospace; font-size: 14px; overflow: auto; padding: 5pt;">#+begin_src clojure :results output :exports both<br /> (def six (+ 1 2 3))<br /> #+end_src<br /><br />#+RESULTS:<br />: => #'user/six<br /></pre>Note that the code got evaluated and is now defined in the repl. So if you evaluate the following (either in the file, or in the repl, you will see:<br /><pre class="example" style="background-color: black; border: 1pt solid rgb(174, 189, 204); color: white; font-family: courier, monospace; font-size: 14px; overflow: auto; padding: 5pt;">#+begin_src clojure :results output :exports both<br />six<br />#+end_src <br /><br />#+RESULTS:<br />: => 6<br /></pre>So you loose nothing of the interactive development you love when coding clojure.</div></div><div class="outline-4" id="outline-container-1-2-3"><h4 id="sec-1-2-3"> <span class="section-number-4">1.2.3</span> Exporting to html</h4><div class="outline-text-4" id="text-1-2-3">When you are done, you can export the file to html by typing C-c C-e h or C-c C-e b to see the exported html in your standart browser. If you want the source code to be colorized like you see it in clojure-mode, you need to install the htmlize package (via elpa) The clojure code shown above will export to the following:<br /><pre class="src src-clojure" style="background-color: black; border: 1pt solid rgb(174, 189, 204); color: white; font-family: courier, monospace; font-size: 14px; overflow: auto; padding: 5pt;">(<span style="color: cyan;">def</span> <span style="color: lightskyblue;">six</span> (<span style="color: #eedd82;">+</span> 1 2 3))<br /></pre><pre class="example" style="background-color: black; border: 1pt solid rgb(174, 189, 204); color: white; font-family: courier, monospace; font-size: 14px; overflow: auto; padding: 5pt;">=> #'user/six<br /></pre>Cool, nicely colored clojure code in your html-documentation or your blog-post. So This should be enough to get you started using org-mode-babel with clojure for Literate Programming. It is interactive like writing normal clojure code and it helps you to think more clearly about your code.</div></div></div><div class="outline-3" id="outline-container-1-3"><h3 id="sec-1-3"> <span class="section-number-3">1.3</span> the org-file</h3><div class="outline-text-3" id="text-1-3">Here is the org-file that you see right now:<br /><br />#+TITLE:Literate Programming in Clojure<br />#+AUTHOR: Maik Schünemann<br />#+email: maikschuenemann@gmail.com<br />#+STARTUP:showall<br />-----<br />* Literate programming in clojure using org-mode babel<br /> In my previous post ... I showed a setup of clojure with org-mode babel using inferior lisp.<br /> In this post I'll first show a double setup with both inferior-lisp and slime, and then I will<br /> show how to use org-babel-clojure for literate programming.<br />** Literate programming<br /> Who doesn't know this situation:<br /> You have to modify someone others code but you have no clue what this code should do. Searching<br /> around the (often barely documentation) doesn't help much either, because it is often not clear<br /> what intention the author had with the code, or why he implemented it that way.<br /> [[http://de.wikipedia.org/wiki/Literate_programming][Literate programming]] does not only help others reading your code, but it helps you as well,because<br /> - writing down your intention and explaining it makes it easier for you to code it<br /> - it helps you to be clear about your design decisions<br /> - writing it down intented to be read by others makes you to automatically write code of better quality<br /> In Literate programming, you mix the explanation of the programm and the source code in one file.<br /> The source code can be automatically extracted. This is called tangling. It is also possible to evaluate<br /> the code while you are in the document.<br />** Org-mode-babel<br /> [[http://orgmode.org/worg/org-contrib/babel/][Babel]] is a part of [[http://orgmode.org/][org-mode]] that is a full featured literate programming program. Being part of org-mode,<br /> it is also able to be exported into a variety of formats including latex and html. I am using it to write<br /> my series of 'Porting PAIP to clojure'. Each blog-post is just a .org file which gets exported to html and<br /> uploaded on blogger. Here is the setup:<br />*** Setting up org-mode-babel with clojure<br /> Fortunately, clojure is a supported language of org-mode, but it's documentation is outdated. So add following<br /> to your .emacs file:<br /> #+begin_src elisp<br /> (require 'ob)<br /> (require 'ob-tangle)<br /> (add-to-list 'org-babel-tangle-lang-exts '("clojure" . "clj"))<br /> <br /> (org-babel-do-load-languages<br /> 'org-babel-load-languages<br /> '((emacs-lisp . t)<br /> (clojure . t)))<br /> (require 'ob-clojure)<br /> <br /> (defun org-babel-execute:clojure (body params)<br /> "Evaluate a block of Clojure code with Babel."<br /> (concat "=> "<br /> (if (fboundp 'slime-eval)<br /> (slime-eval `(swank:interactive-eval-region ,body))<br /> (if (fboundp 'lisp-eval-string)<br /> (lisp-eval-string body)<br /> (error "You have to start a clojure repl first!")))))<br /> <br /> (setq org-src-fontify-natively t)<br /> (setq org-confirm-babel-evaluate nil)<br /> (setq org-export-babel-evaluate nil)<br /> (setq org-src-window-setup 'current-window)<br /> (setq inferior-lisp-program "lein repl")<br /> #+end_src<br /> (I assume you have a recent org-mode installed)<br /> It will work with either inferior lisp using lein repl, which has the advantage that you can run it without<br /> a project.clj file, or with M-x clojure-jack-in, which gives you the goddies of slime with clojure.<br /><br /> I have also written a few lines to make the exported html look better and defined a skeleton to quickly insert<br /> the first lines in the .org file. If you type C-S-f4, you will be prompted for the title and the content of the<br /> skeleton will be inserted.<br /> #+begin_src elisp<br /> (define-skeleton org-skeleton<br /> "Header info for a emacs-org file."<br /> "Title: "<br /> "#+TITLE:" str " \n"<br /> "#+AUTHOR: Maik Schünemann\n"<br /> "#+email: maikschuenemann@gmail.com\n"<br /> "#+STARTUP:showall\n"<br /> "-----"<br /> )<br /> (global-set-key [C-S-f4] 'org-skeleton)<br /><br /> (setq org-export-html-style-extra "<style type=\"text/css\">pre {\n border: 1pt solid #AEBDCC;\n<span class="Apple-tab-span" style="white-space: pre;"> </span>color:white;\n background-color: #000000;\n<span class="Apple-tab-span" style="white-space: pre;"> </span>padding: 5pt;\n<span class="Apple-tab-span" style="white-space: pre;"> </span>font-family: courier, monospace;\n font-size: 90%;\n overflow:auto;\n } </style>")<br /> #+end_src<br /> <br />*** Interacting with clojure code.<br /> Start a repl first. Either via M-x run-lisp or with M-x clojure-jack-in. Note, if you use the former, the<br /> result of the code won't get inserted in the .org file after evaluation.<br /><br /> To write some clojure-code, type the following (may be good to define a kbd-macro to speed this up)<br /> #+begin_example<br /> #+begin_src clojure :results output :exports both<br /> (def six (+ 1 2 3))<br /> #+end_src<br /> #+end_example<br /> If you place your cursor between the begin_src and end_src and type C-c C-c, you will see the following:<br /> #+begin_example<br /> #+begin_src clojure :results output :exports both<br /> (def six (+ 1 2 3))<br /> #+end_src<br /><br /> #+RESULTS:<br /> : => #'user/six<br /> #+end_example<br /> Note that the code got evaluated and is now defined in the repl. So if you evaluate the following (either in<br /> the file, or in the repl, you will see:<br /> #+begin_example<br /> #+begin_src clojure :results output :exports both<br /> six<br /> #+end_src<br /><br /> #+RESULTS:<br /> : => 6<br /> #+end_example<br /> So you loose nothing of the interactive development you love when coding clojure.<br /><br />*** Exporting to html<br /> When you are done, you can export the file to html by typing C-c C-e h or C-c C-e b to see the exported<br /> html in your standart browser.<br /> If you want the source code to be colorized like you see it in clojure-mode, you need to install the<br /> htmlize package (via elpa)<br /> The clojure code shown above will export to the following:<br /><br /> #+begin_src clojure :results output :exports both<br /> (def six (+ 1 2 3))<br /> #+end_src<br /><br /> #+RESULTS:<br /> : => #'user/six<br /> Cool, nicely colored clojure code in your html-documentation or your blog-post.<br /> So This should be enough to get you started using org-mode-babel with clojure for Literate Programming.<br /> It is interactive like writing normal clojure code and it helps you to think more clearly about your code.<br /><br />** the org-file<br /> Here is the org-file that you see right now:<br /> (leaving this part out to avoid infinite file size...)<br /><br /></div></div></div></div><div id="postamble" style="font-family: Times, serif; font-size: 16px;"><div class="date">Date: 2012-05-30T11:17+0200</div><div class="author">Author: Maik Schünemann</div><div class="creator">Org version 7.8.09 with Emacs version 23</div><a href="http://validator.w3.org/check?uri=referer">Validate XHTML 1.0</a></div><div class="blogger-post-footer"></div><div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=LAteEpd8sAo:xiel2AqVCEw:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=LAteEpd8sAo:xiel2AqVCEw:qj6IDK7rITs"></img></a> </div> </article> <article> <h1><link href="http://feedproxy.google.com/~r/clojure/~3/r-ZYJJeyp1A/setting-up-org-mode-babel-with-clojure.html" /> <id>tag:blogger.com,1999:blog-3908276794795362019.post-5689836547276123388</id> <updated>2012-05-30T10:56:30+00:00</updated> <content type="html">setting up org-mode babel with clojure <br /><div id="preamble"></div><div id="content"><h2 style="text-align: center;"> <span style="font-size: x-large;">Setting up org-mode babel with clojure</span></h2><div id="table-of-contents"><h2> Table of Contents</h2><div id="text-table-of-contents"><ul><li><a href="http://www.blogger.com/blogger.g?blogID=3908276794795362019#sec-1">1 Setting up org-mode babel with clojure</a><ul><li><a href="http://www.blogger.com/blogger.g?blogID=3908276794795362019#sec-1-1">1.1 Setting up babel to work with clojure</a><ul><li><a href="http://www.blogger.com/blogger.g?blogID=3908276794795362019#sec-1-1-1">1.1.1 A partial Solution</a></li><li><a href="http://www.blogger.com/blogger.g?blogID=3908276794795362019#sec-1-1-2">1.1.2 Missing features</a></li></ul></li><li><a href="http://www.blogger.com/blogger.g?blogID=3908276794795362019#sec-1-2">1.2 Final thoughts</a></li></ul></li></ul></div></div><div class="outline-2" id="outline-container-1"><h2 id="sec-1"> <span class="section-number-2">1</span> Setting up org-mode babel with clojure</h2><div class="outline-text-2" id="text-1">For my new series 'Porting PAIP to clojure' I plan to write my blogposts as literate programming files using emacs org-mode with babel set up for clojure. This file can be exportet to html using org-publish-as-html and posted on my blog. I was glad to notice that clojure is <a href="http://orgmode.org/worg/org-contrib/babel/languages.html">one of the supported languages</a> of babel </div><div class="outline-3" id="outline-container-1-1"><h3 id="sec-1-1"> <span class="section-number-3">1.1</span> Setting up babel to work with clojure</h3><div class="outline-text-3" id="text-1-1">There is a <a href="http://orgmode.org/worg/org-contrib/babel/languages/ob-doc-clojure.html">Instruction page</a> for setting up Org-babel-clojure. However, It is outdated (It <a href="http://lists.gnu.org/archive/html/emacs-orgmode/2012-01/msg00507.html">depends on the deprecated swank-clojure</a> and doesn't work with the normal clojure + emacs setup described <a href="http://dev.clojure.org/display/doc/Getting+Started+with+Emacs">here</a>. </div><div class="outline-4" id="outline-container-1-1-1"><h4 id="sec-1-1-1"> <span class="section-number-4">1.1.1</span> A partial Solution</h4><div class="outline-text-4" id="text-1-1-1">After googling a bit I found out that you seem to need <a href="http://nakkaya.com/2010/12/12/using-clojure-with-org-babel-and-inferior-lisp/">this code</a> to set it up: <br /><pre class="example">(require 'ob)<br /><br />(add-to-list 'org-babel-tangle-lang-exts '("clojure" . "clj"))<br /><br />(defvar org-babel-default-header-args:clojure <br />'((:results . "silent") (:tangle . "yes")))<br /><br />(defun org-babel-execute:clojure (body params)<br />"Evaluate a block of Clojure code with Babel."<br />(lisp-eval-string body)<br />"Done!")<br /><br />(provide 'ob-clojure)<br /></pre>There is only one problem: It doesn't work with a clojure-slime session started. It gives a Symbol's function definition is void: lisp-eval-string Error. This seemed very strange to me because apparently no one but me had this error. I spend a bit time searching where the function (lisp-eval-string) is defined. The solution (which seems now very naturally to me but costed my half an hour to find out) is that you have to use clojure with Inferior-lisp instead of slime. So add the following line to your .emacs <br /><pre class="example">(setq inferior-lisp-program "lein repl")<br /></pre>Then, running M-x run-lisp starts a repl with the correct classpath set up for you. <br />When you followed the steps, running C-c C-c in a clojure source blog sends the s-exp to your <b>inferior-lisp</b> buffer where it is evaluated. <br />With this I have a miminally usable set up for org-mode-babel and clojure and are ready to start using it for porting PAIP to clojure. </div></div><div class="outline-4" id="outline-container-1-1-2"><h4 id="sec-1-1-2"> <span class="section-number-4">1.1.2</span> Missing features</h4><div class="outline-text-4" id="text-1-1-2">It turns out that only the most basic functionality is available with this setup. According to the <a href="http://orgmode.org/worg/org-contrib/babel/languages/ob-doc-clojure.html">instruction page</a> org-babel supports sessions and you can specify whether the result is shown in the org-mode buffer when evaluated. <br /><ul><li id="sec-1-1-2-1">Results<br /> As example, insert this code blog in a .org file <pre class="example">#+name: basic-session-clojure-table-results<br />#+begin_src clojure :session s1 :results value<br /> [ 1 2 3 4]<br />#+end_src<br /></pre>and evaluate C-c C-c whith the point within the source block. the instruction page says that the following block should have been inserted: <br /> <pre class="example">#+resname: basic-session-clojure-table-results<br />| 1 | 2 | 3 | 4 |<br /></pre>(the vector has been automagically converted to an org-mode table) <br /> This doesn't work with this setup, because (lisp-eval-string text) returns nil. The result is only shown in the <b>inferior-lisp</b> buffer and I don't know if there is a way getting the result back. <br /> But with emacs, I was able to automate the process of getting the results from the <b>inferior-lisp</b> buffer using a keyboard-macro. The macro consists of the following steps: <br /><ol><li>Execute C-c C-c </li><li>M-x b to the <b>inferior-lisp</b> buffer </li></ol>the s-exp has now been evaluated and a new user> line was printed. <br /><ol><li>Go one line up and copy everything starting after user> to get the result </li><li>Switch to the org-buffer again </li><li>Copy the result - I insert following text: ;=> result </li><li>Switch to the <b>inferior-lisp</b> buffer again </li><li>place cursor at it's original position that is at the end of the buffer </li><li>Switch to the org-bugger </li></ol>It is a rather lengthy kbd-macro but it does it's job. I recommend that you name it so that you don't have to define it again and again :) (emacs supports the lazy one) <br /> I think it would be better to implement that as a elisp function but I don't know enough emacs-lis to do this. Any help would be appreciated </li></ul><ul><li id="sec-1-1-2-2">Sessions<br /> Org-mode-babel has also support for multiple sessions which run independend from another. Consider following example (also from the instruction page) <pre class="example">#+name: set-clojure-session-var-s1<br />#+begin_src clojure :session s1 :results value<br />(def *var* [1 2 3])<br />#+end_src<br /> <br />#+name: set-clojure-session-var-s2<br />#+begin_src clojure :session s2 :results value<br />(def *var* [3 4 5 6 7 8 9])<br />#+end_src<br /> <br />#+name: get-clojure-session-var-s1<br />#+begin_src clojure :session s1 :results value<br />(count *var*)<br />#+end_src<br /> <br />#+name: get-clojure-session-var-s2<br />#+begin_src clojure :session s2 :results value<br />(count *var*)<br />#+end_src<br /></pre>This should open 2 slime-sessions and insert the results after the src-blocks. It doesn't work too. org-babel clojure isn't able to start a slime-session. I have not implemented a workaround for this because I think I won't need it right now, but here are my thoughts of how to implement sessions: <br /> When org-babel clojure should start a session it first checks whether a Buffer with the session name already exists. If not, it runs the run-lisp command and renames the <b>inferior-lisp</b> buffer to the session's name. If it exists it sets the buffer to the actual inferior lisp buffer according to the comment <a href="http://www.audacity-forum.de/download/edgar/nyquist/nyquist-doc/examples/emacs/sources/inferior-lisp.html">here</a>. After this it runs a function to get the result from the buffer and inserts it after the src blog (see the section results above) <br /> </li></ul></div></div></div><div class="outline-3" id="outline-container-1-2"><h3 id="sec-1-2"> <span class="section-number-3">1.2</span> Final thoughts</h3><div class="outline-text-3" id="text-1-2">org-mode + babel is a great tool for literate programming. Althoug the described setup is outdated and doesn't work know, with the setup descripbed above you can use the basic features of org-babel-clojure. The not language agnostic functions are working of course! <br />I am thankfull for any comment/recommendation regarding the setup and for advice/help how to implement this in emacs lisp and contributing it back to org-babel. <br />Is there any function in swank-clojure which can be used to send code to the SLIME buffer and returns the result?<br /><br /></div></div></div></div><div id="postamble"><div class="date">Date: 2012-05-27T23:06+0200</div><div class="author">Author: kima</div><div class="creator">Org version 7.8.09 with Emacs version 23</div><a href="http://validator.w3.org/check?uri=referer">Validate XHTML 1.0</a> </div><div class="blogger-post-footer"><img alt="" height="1" src="https://blogger.googleusercontent.com/tracker/3908276794795362019-5689836547276123388?l=kimavcrp.blogspot.com" width="1" /></div><div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=r-ZYJJeyp1A:ybovqkwRxUc:I9og5sOYxJI"><img src="http://feeds.feedburner.com/~ff/clojure?d=I9og5sOYxJI" border="0"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=r-ZYJJeyp1A:ybovqkwRxUc:qj6IDK7rITs"><img src="http://feeds.feedburner.com/~ff/clojure?d=qj6IDK7rITs" border="0"></img></a> </div><img src="http://feeds.feedburner.com/~r/clojure/~4/r-ZYJJeyp1A" height="1" width="1"/></content> <author> <name>Maik Schünemann</name> <email>noreply@blogger.com</email> <uri>http://kimavcrp.blogspot.com/search/label/clojure</uri> </author> <source> <title type="html">Exploring the programming world</h1> <p>2012-05-30T10:56:30+00:00</p> setting up org-mode babel with clojure <br /><div id="preamble"></div><div id="content"><h2 style="text-align: center;"> <span style="font-size: x-large;">Setting up org-mode babel with clojure</span></h2><div id="table-of-contents"><h2> Table of Contents</h2><div id="text-table-of-contents"><ul><li><a href="http://www.blogger.com/blogger.g?blogID=3908276794795362019#sec-1">1 Setting up org-mode babel with clojure</a><ul><li><a href="http://www.blogger.com/blogger.g?blogID=3908276794795362019#sec-1-1">1.1 Setting up babel to work with clojure</a><ul><li><a href="http://www.blogger.com/blogger.g?blogID=3908276794795362019#sec-1-1-1">1.1.1 A partial Solution</a></li><li><a href="http://www.blogger.com/blogger.g?blogID=3908276794795362019#sec-1-1-2">1.1.2 Missing features</a></li></ul></li><li><a href="http://www.blogger.com/blogger.g?blogID=3908276794795362019#sec-1-2">1.2 Final thoughts</a></li></ul></li></ul></div></div><div class="outline-2" id="outline-container-1"><h2 id="sec-1"> <span class="section-number-2">1</span> Setting up org-mode babel with clojure</h2><div class="outline-text-2" id="text-1">For my new series 'Porting PAIP to clojure' I plan to write my blogposts as literate programming files using emacs org-mode with babel set up for clojure. This file can be exportet to html using org-publish-as-html and posted on my blog. I was glad to notice that clojure is <a href="http://orgmode.org/worg/org-contrib/babel/languages.html">one of the supported languages</a> of babel </div><div class="outline-3" id="outline-container-1-1"><h3 id="sec-1-1"> <span class="section-number-3">1.1</span> Setting up babel to work with clojure</h3><div class="outline-text-3" id="text-1-1">There is a <a href="http://orgmode.org/worg/org-contrib/babel/languages/ob-doc-clojure.html">Instruction page</a> for setting up Org-babel-clojure. However, It is outdated (It <a href="http://lists.gnu.org/archive/html/emacs-orgmode/2012-01/msg00507.html">depends on the deprecated swank-clojure</a> and doesn't work with the normal clojure + emacs setup described <a href="http://dev.clojure.org/display/doc/Getting+Started+with+Emacs">here</a>. </div><div class="outline-4" id="outline-container-1-1-1"><h4 id="sec-1-1-1"> <span class="section-number-4">1.1.1</span> A partial Solution</h4><div class="outline-text-4" id="text-1-1-1">After googling a bit I found out that you seem to need <a href="http://nakkaya.com/2010/12/12/using-clojure-with-org-babel-and-inferior-lisp/">this code</a> to set it up: <br /><pre class="example">(require 'ob)<br /><br />(add-to-list 'org-babel-tangle-lang-exts '("clojure" . "clj"))<br /><br />(defvar org-babel-default-header-args:clojure <br />'((:results . "silent") (:tangle . "yes")))<br /><br />(defun org-babel-execute:clojure (body params)<br />"Evaluate a block of Clojure code with Babel."<br />(lisp-eval-string body)<br />"Done!")<br /><br />(provide 'ob-clojure)<br /></pre>There is only one problem: It doesn't work with a clojure-slime session started. It gives a Symbol's function definition is void: lisp-eval-string Error. This seemed very strange to me because apparently no one but me had this error. I spend a bit time searching where the function (lisp-eval-string) is defined. The solution (which seems now very naturally to me but costed my half an hour to find out) is that you have to use clojure with Inferior-lisp instead of slime. So add the following line to your .emacs <br /><pre class="example">(setq inferior-lisp-program "lein repl")<br /></pre>Then, running M-x run-lisp starts a repl with the correct classpath set up for you. <br />When you followed the steps, running C-c C-c in a clojure source blog sends the s-exp to your <b>inferior-lisp</b> buffer where it is evaluated. <br />With this I have a miminally usable set up for org-mode-babel and clojure and are ready to start using it for porting PAIP to clojure. </div></div><div class="outline-4" id="outline-container-1-1-2"><h4 id="sec-1-1-2"> <span class="section-number-4">1.1.2</span> Missing features</h4><div class="outline-text-4" id="text-1-1-2">It turns out that only the most basic functionality is available with this setup. According to the <a href="http://orgmode.org/worg/org-contrib/babel/languages/ob-doc-clojure.html">instruction page</a> org-babel supports sessions and you can specify whether the result is shown in the org-mode buffer when evaluated. <br /><ul><li id="sec-1-1-2-1">Results<br /> As example, insert this code blog in a .org file <pre class="example">#+name: basic-session-clojure-table-results<br />#+begin_src clojure :session s1 :results value<br /> [ 1 2 3 4]<br />#+end_src<br /></pre>and evaluate C-c C-c whith the point within the source block. the instruction page says that the following block should have been inserted: <br /> <pre class="example">#+resname: basic-session-clojure-table-results<br />| 1 | 2 | 3 | 4 |<br /></pre>(the vector has been automagically converted to an org-mode table) <br /> This doesn't work with this setup, because (lisp-eval-string text) returns nil. The result is only shown in the <b>inferior-lisp</b> buffer and I don't know if there is a way getting the result back. <br /> But with emacs, I was able to automate the process of getting the results from the <b>inferior-lisp</b> buffer using a keyboard-macro. The macro consists of the following steps: <br /><ol><li>Execute C-c C-c </li><li>M-x b to the <b>inferior-lisp</b> buffer </li></ol>the s-exp has now been evaluated and a new user> line was printed. <br /><ol><li>Go one line up and copy everything starting after user> to get the result </li><li>Switch to the org-buffer again </li><li>Copy the result - I insert following text: ;=> result </li><li>Switch to the <b>inferior-lisp</b> buffer again </li><li>place cursor at it's original position that is at the end of the buffer </li><li>Switch to the org-bugger </li></ol>It is a rather lengthy kbd-macro but it does it's job. I recommend that you name it so that you don't have to define it again and again :) (emacs supports the lazy one) <br /> I think it would be better to implement that as a elisp function but I don't know enough emacs-lis to do this. Any help would be appreciated </li></ul><ul><li id="sec-1-1-2-2">Sessions<br /> Org-mode-babel has also support for multiple sessions which run independend from another. Consider following example (also from the instruction page) <pre class="example">#+name: set-clojure-session-var-s1<br />#+begin_src clojure :session s1 :results value<br />(def *var* [1 2 3])<br />#+end_src<br /> <br />#+name: set-clojure-session-var-s2<br />#+begin_src clojure :session s2 :results value<br />(def *var* [3 4 5 6 7 8 9])<br />#+end_src<br /> <br />#+name: get-clojure-session-var-s1<br />#+begin_src clojure :session s1 :results value<br />(count *var*)<br />#+end_src<br /> <br />#+name: get-clojure-session-var-s2<br />#+begin_src clojure :session s2 :results value<br />(count *var*)<br />#+end_src<br /></pre>This should open 2 slime-sessions and insert the results after the src-blocks. It doesn't work too. org-babel clojure isn't able to start a slime-session. I have not implemented a workaround for this because I think I won't need it right now, but here are my thoughts of how to implement sessions: <br /> When org-babel clojure should start a session it first checks whether a Buffer with the session name already exists. If not, it runs the run-lisp command and renames the <b>inferior-lisp</b> buffer to the session's name. If it exists it sets the buffer to the actual inferior lisp buffer according to the comment <a href="http://www.audacity-forum.de/download/edgar/nyquist/nyquist-doc/examples/emacs/sources/inferior-lisp.html">here</a>. After this it runs a function to get the result from the buffer and inserts it after the src blog (see the section results above) <br /> </li></ul></div></div></div><div class="outline-3" id="outline-container-1-2"><h3 id="sec-1-2"> <span class="section-number-3">1.2</span> Final thoughts</h3><div class="outline-text-3" id="text-1-2">org-mode + babel is a great tool for literate programming. Althoug the described setup is outdated and doesn't work know, with the setup descripbed above you can use the basic features of org-babel-clojure. The not language agnostic functions are working of course! <br />I am thankfull for any comment/recommendation regarding the setup and for advice/help how to implement this in emacs lisp and contributing it back to org-babel. <br />Is there any function in swank-clojure which can be used to send code to the SLIME buffer and returns the result?<br /><br /></div></div></div></div><div id="postamble"><div class="date">Date: 2012-05-27T23:06+0200</div><div class="author">Author: kima</div><div class="creator">Org version 7.8.09 with Emacs version 23</div><a href="http://validator.w3.org/check?uri=referer">Validate XHTML 1.0</a> </div><div class="blogger-post-footer"></div><div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=r-ZYJJeyp1A:ybovqkwRxUc:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=r-ZYJJeyp1A:ybovqkwRxUc:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>Emacs commands for Clojure development</h1> <p>2012-05-30T08:28:14+00:00</p> <div class="separator" style="clear: both; text-align: center;"><a href="http://files.fosswire.com/2010/06/emacs_logo.png" style="clear: right; float: right; margin-bottom: 1em; margin-left: 1em;"></a></div>At the London Clojure dojo we use the amazing environment of Emacs to write and run our tests and code. Emacs is a very powerful environment, more than just the editor it seems at first glance and using a tool written in Lisp is very fitting considering we are learning Clojure, a dialect of Lisp.<br /><br />As we have emacs set up to be driven by keyboard shortcuts (as we only get 10 minutes each to code) I have made a crib sheet for the most common keyboard shortcuts and commands.<br /><br /><b> </b><br /><b>Emacs crib sheet</b><br />A quick crib sheet for Clojure development using Emacs (see <a href="http://clojure.jr0cket.co.uk/tool-support/emacs-leiningen-swank">setup guide)</a><br /><br /><table border="0" cellpadding="8" cellspacing="0" style="border-collapse: collapse; border-color: rgb(136, 136, 136); border-width: 1px;"><tbody><tr> <td style="height: 16px; width: 118px;"><span style="font-size: small;"><b> File Management</b></span></td> <td style="height: 16px; width: 148px;"><br /></td> <td style="height: 16px; width: 36px;"><br /></td> <td style="height: 16px; width: 151px;"><span style="font-size: small;"><b> Buffer Management</b></span><br /><br /></td> <td style="height: 16px; width: 125px;"><br /></td> </tr><tr> <td style="height: 16px; width: 118px;"> <b>Open</b> </td> <td style="height: 16px; width: 148px;"> Ctrl-X, Ctrl-F </td> <td style="height: 16px; width: 36px;"><br /></td> <td style="height: 16px; width: 151px;"> Close Window/Buffer </td> <td style="height: 16px; width: 125px;"> Ctrl-X, K </td> </tr><tr> <td style="height: 16px; width: 118px;"> Save </td> <td style="height: 16px; width: 148px;"> Ctrl-X, Ctrl-S </td> <td style="height: 16px; width: 36px;"><br /></td> <td style="height: 16px; width: 151px;"> Quit </td> <td style="height: 16px; width: 125px;"> Ctrl-X, Ctrl-C </td> </tr><tr> <td style="height: 16px; width: 118px;"> Save As </td> <td style="height: 16px; width: 148px;"> Ctrl-X, Ctrl-W</td> <td style="height: 16px; width: 36px;"><br /></td> <td style="height: 16px; width: 151px;"> Scroll through buffers</td> <td style="height: 16px; width: 125px;"> Ctrl-X, B</td> </tr><tr> <td style="height: 20px; width: 118px;"> Save All </td> <td style="height: 20px; width: 148px;"> Ctrl-X, S </td> <td style="height: 20px; width: 36px;"><br /></td> <td style="height: 20px; width: 151px;"> <b>List buffers in window</b></td> <td style="height: 20px; width: 125px;"> Ctrl-X, Ctrl-B </td> </tr><tr> <td style="height: 16px; width: 118px;"> Revert to File </td> <td style="height: 16px; width: 148px;"> Ctrl-X, Ctrl-V </td> <td style="height: 16px; width: 36px;"><br /></td> <td style="height: 16px; width: 151px;"> Maximise</td> <td style="height: 16px; width: 125px;"> Ctrl-X, 1 <br /><br /></td> </tr><tr> <td style="height: 16px; width: 118px;"> Revert Buffer </td> <td style="height: 16px; width: 148px;"> Meta-X, revert-buffer </td> <td style="height: 16px; width: 36px;"><br /></td> <td style="height: 16px; width: 151px;"> Split Horizontally<br /><br /></td> <td style="height: 16px; width: 125px;"> Ctrl-X, 2 <br /><br /></td> </tr><tr> <td style="height: 16px; width: 118px;"><br /></td> <td style="height: 16px; width: 148px;"><br /></td> <td style="height: 16px; width: 36px;"><br /></td> <td style="height: 16px; width: 151px;"><b> Split Vertically</b><br /><br /></td> <td style="height: 16px; width: 125px;"> Ctrl-X, 3 </td> </tr><tr> <td><span style="font-size: small;"><b> Text management</b></span><br /><br /></td> <td><br /></td> <td><br /></td> <td> <b>Switch focus between windows</b><br /><br /></td> <td> Ctrl-X, o </td> </tr><tr> <td> Cut Line</td> <td> Ctrl-k</td> <td><br /></td> <td>Close current buffer <br /><br /></td> <td>Ctrl-X, 0 (zero) <br /><br /></td> </tr><tr> <td> Paste</td> <td> Ctrl-y</td> <td><br /></td> <td><br /></td> <td><br /></td> </tr><tr> <td> Undo</td> <td> Ctrl-_ <br /><br /></td> <td><br /></td> <td> <span style="font-size: small;"><b>Build management</b></span><br /><br /></td> <td> <br /><br /></td> </tr><tr> <td>Cut selection <br /><br /></td> <td> Ctrl-w</td> <td><br /></td> <td>Compile code <br /><br /></td> <td> Ctrl-c, Ctrl-k<br /><br /></td> </tr></tbody> </table><br /><b>Notes</b><br /><br />When opening a file, use the <b>backscape</b> key to navigate to parent folder<br /><br /><br /><br /><b>Running the Clork project</b><br />Once you have Emacs and Leiningen set up and have downloaded the clork code, you can use the project using these steps<br /><br />In a terminal window, change to the root of the clork project. Run the leiningen command to run Swank<br /><br /><b>lein swank</b><br /><br />You will get a message to saying you are connected to the Swank server<br /><br />Open emacs from the root of the clork project and enter the following command to connect to the Swank server<br /><br /><b>Meta-X slime connect</b><div class="blogger-post-footer"></div><div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=xn3D8cI_hUg:OIRBmu51GK8:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=xn3D8cI_hUg:OIRBmu51GK8:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>London Clojure dojo - 27th September 2011</h1> <p>2012-05-30T08:27:14+00:00</p> <div class="separator" style="clear: both; text-align: center;"><a href="https://ldncljdojo.eventwax.com/uploaded/logo//early-may-2011-london-clojure-dojo/20110419095837-ldncljdojo.png?1303207117" style="clear: left; float: left; margin-bottom: 1em; margin-right: 1em;"></a></div>As always the dojo started with a feast of pizza and drinks courtesy of ThoughWorks, the perennial favorite it seems with developers (I use it at my Scala dojos for the same effect). A good turn out tonight meant the pizza went down quickly and we got onto the intros, with the monthly mystery question "If your names' not Bruce, what would it be" nicely stolen from Monty Python.<br /><br />Tonight's challenge was a children's classic - 20 Questions. We set up a server to hold a expert system style data structure to help the teams play the game. The challenge was two fold in playing the game in the first place and then adding to the question/answer data structure.<br /><br />With enough people for 5 teams we split up into our groups and cracked on with the challenge. Team two were using my trusty Lenovo laptop running Ubuntu, with the timeless classic emacs editor. Emacs had the obligatory starter kick installed and the project was set up with Lein for the dependency management and Swank for the REPL.<br /><br />Once we hooked up Emacs to the local swank server we were off... well once we figured out what on earth to do first.<br /><br />The challenges of a dojo are the blank project, what do we do first. You either pontificate for a while, come up with 5 different opinions or if you are very lucky decide to jump at the first idea you have and crack on with it - knowing you will refactor it with in about 5 minutes - but thats the fun of the dojo...<br /><br />Change is good... fast feedback is good... putting stuff in the REPL is a life saver...<br /><br />To connect to the 20 Questions server we used the CLJ-HTTP library, pretty easy to use with simple get and put commands and a standard require statement for the library. Adding the library to the project.clj and running lein deps brought down the relevant libraries and dependencies (just like a mini maven, but without half the Internet).<br /><br />A few of different routes were quickly tried out but we quickly settled on an atom based data structure - as we were going to do updates to it. We could have done something more elegant though this route was good enough for what we needed.<br /><br /><br /><b>Conclusion</b><br />Working in a tight knit group for about two hours working on a challenge is a very effective ways of exploring and getting a handle on a new language. With a group of people who all have different ideas and experiences you take away a lot of things to think about. I can see why people are driven to do more straight after a dojo and re-do the challenge in some of the different ways discussed. I always get a great confidence boost for my clojure efforts, even though (or maybe because) I am far from proficient.<br /><br />The code is up on GitHub for the world to see and its interesting to understand what a random group with a little bit of knowledge and <a href="http://clojuredocs.org/">clojuredocs.org</a> can achieve in under two hours...<div class="blogger-post-footer"></div><div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=IccdOEo4Mow:wxD8DD0ijDI:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=IccdOEo4Mow:wxD8DD0ijDI:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>Beanstalk + Clojure = Love (and 20x better performance)</h1> <p>2012-05-29T17:50:50+00:00</p> <p><a class="tumblr_blog" href="http://blog.beanstalkapp.com/post/23998022427/beanstalk-clojure-love-and-20x-better-performance" rel="nofollow" target="_blank">beanstalkapp</a>:</p> <blockquote> <p>I try to only post on the Beanstalk blog when I have something cool to post about and today is the perfect occasion. Yesterday we deployed to production a rewrite of Beanstalk’s caching system written in <a href="http://clojure.org/" rel="nofollow" target="_blank">Clojure</a>. It is <strong>20 times faster</strong> than the previous version that was written in Ruby and allowed us to bring the latency between committing a change to a repo and seeing the update in Beanstalk’s UI to an average of <strong>20 ms</strong>.</p> <p>Here I’ll try to explain how and why we did it. But first let me explain the Beanstalk caching architecture.</p> <p><a href="http://blog.beanstalkapp.com/post/23998022427/beanstalk-clojure-love-and-20x-better-performance" rel="nofollow" target="_blank">Read More</a></p> </blockquote><div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=giwSoDNVccw:We6r0PSoirU:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=giwSoDNVccw:We6r0PSoirU:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>Presentation: Why Prismatic Goes Faster With Clojure</h1> <p>2012-05-29T15:10:00+00:00</p> Bradford Cross recommends creating custom libraries containing composable abstractions instead of monolithic frameworks, exemplifying with Flop, Store, Graph, and Newsfeeds, all written in Clojure. <i>By Bradford Cross</i><div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=p8tKWrWPs8k:WRnBJY_fxEg:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=p8tKWrWPs8k:WRnBJY_fxEg:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>Beanstalk + Clojure = Love (and 20x better performance)</h1> <p>2012-05-29T14:57:29+00:00</p> <p>I try to only post on the Beanstalk blog when I have something cool to post about and today is the perfect occasion. Yesterday we deployed to production a rewrite of Beanstalk’s caching system written in <a href="http://clojure.org/" rel="nofollow" target="_blank">Clojure</a>. It is <b>20 times faster</b> than the previous version that was written in Ruby and allowed us to bring the latency between committing a change to a repo and seeing the update in Beanstalk’s UI to an average of <b>20 ms</b>. </p> <p>Here I’ll try to explain how and why we did it. But first let me explain the Beanstalk caching architecture.</p> <h3>Beanstalk Caching Architecture</h3> <p>When a commit or a push is made to a repository hosted on Beanstalk it first goes directly to the repository on our high availability storage servers. This way we make sure that your commits are safe and that if any error happens, your version control client will let you know immediately. </p> <p>The next step is commit caching, when we take the commit information from the repo and put in the database. This is to make sure we don’t need to hit the disks every time we need a tiny bit of information about your files or commits. This greatly improves your general Beanstalk experience — from the web UI to email notifications to deployments.</p> <p>After the commit is cached it is then transferred further to trigger email notifications, various integrated services, automated deployments and update various stats in your account.</p> <p>To fetch commit information from the repos in Beanstalk we use several different APIs — for each of the version control systems we support:</p> <ul><li>Official Subversion Ruby bindings (which bind Ruby with Subversion’s C library)</li> <li><a href="https://github.com/mojombo/grit" rel="nofollow" target="_blank">Grit</a> for Git (which is a mix of pure Ruby code with bits of Git command line client output parsing)</li> <li>Our own <a href="https://github.com/isabanin/mercurial-ruby" rel="nofollow" target="_blank">Ruby gem for Mercurial</a></li> </ul><h3>So What’s The Problem?</h3> <p>The problem was that commit caching was frequently quite slow. For Subversion repositories big commits could easily take 30 seconds to cache. If a new Subversion repository was imported into Beanstalk, it could take up to 10 minutes to cache. </p> <p>For Git the situation was even worse, since each push can potentially represent thousands of commits it could easily take 30 minutes to cache it. If your Git repo has a lot of branches, then it could take even more time. Now if you imagine that we have to process thousands commits every hour, this could easily become a problem for our servers and sometimes it was.</p> <p>I probably need to explain why Git is much slower for us — it’s because of the way we represent Git activity timeline. We think that all commits to different branches should be viewable together in a single timeline, so we have to perform an extra bit of caching to get additional information about branches structure and what commit was pushed to which branch first (even though Git doesn’t provide this information easily).</p> <p>Basically, our problem was caused by the fact that we relied on some not very efficient algorithms to build our caches (due to the API restrictions of SVN bindings and Grit library) and the fact that we used Ruby in such a critical place for Beanstalk’s performance.</p> <h3>Clojure to the Rescue</h3> <p>I’ve been looking for an excuse to use Clojure in a production environment for a while. If you don’t know what Clojure is — it’s a Lisp dialect that runs on a <a href="http://en.wikipedia.org/wiki/Java_virtual_machine" rel="nofollow" target="_blank" title="Java Virtual Machine">JVM</a>. You get the best of the both worlds - amazing power and clarity of a modern Lisp and huge variety of production ready Java libraries out there.</p> <p><b>Clojure is an awesome language that brings Lisp into the 21st century.</b> It provides great support for concurrency out of the box, it’s a functional language with a lot of things done right and it has a very vibrant community with lots of extremely smart people. The fact that it integrates seamlessly with Java allows you to use all the code from the Java world without writing a line of Java.</p> <p>So the best thing is that with some optimizations (like optional type hints) Clojure can be made to run almost as fast as native Java. But even without any optimizations Clojure code is easily 30-50 times faster than regular Ruby code on artificial benchmarks, and that sounded like a great plan to me!</p> <p>There are also some amazing libraries for version control system for Java that I could use through Clojure right away:</p> <ul><li><a href="http://svnkit.com/" rel="nofollow" target="_blank">SVNKit</a> for Subversion (Used by Oracle, IBM, Novell, Borland)</li> <li><a href="http://www.jgit.org/" rel="nofollow" target="_blank">JGit</a> used by Eclipse</li> </ul><p>There’s also plenty of <a href="http://clojure-toolbox.com" rel="nofollow" target="_blank">great libraries for Clojure</a> and many more appear each day. All this made Clojure a great candidate for a second language to be added to the Beanstalk team’s toolbox.</p> <h3>The Results</h3> <p>The rewrite in Clojure resulted in much cleaner, faster code, totaling at only 700 lines of Clojure code (I don’t have a clear comparison with Ruby code here). Some of the features of our new caching daemon are:</p> <ul><li>It’s very fast. <b>Subversion caching is more than 15-20 times faster</b> than our previous Ruby version. <b>Git caching is 50 times faster</b> than before.</li> <li>It is multi-threaded so it doesn’t spawn processes when new job comes in, so it’s very fast at catching new commits. It’s also more efficient and we’ll be able to process more commits with it.</li> <li>It’s deployed as a single JAR file that we can run on any of our machines that are connected to the HA file storage. That will allow us to scale our commit caching capacity in matter of minutes on spare machines.</li> <li>Very low latency - it starts caching new commits before you press that commit button :).</li> </ul><h3>What Does This Mean To Our Customers?</h3> <ul><li>Commits appearing in timeline nearly instantly.</li> <li>Deployments will be triggered faster.</li> <li>Generally better caching as Clojure is not having problems with commits that were “too large” to cache for our Ruby version.</li> <li>More consistent caching results, no unicode issues even in weird cases.</li> </ul><h3>Future Plans</h3> <p>We plan to improve our caching even more by running the caching daemon on our backup storage servers, which will make commit caching even faster as we would bypass NFS latency.</p> <p>Our experience of using Clojure for real world stuff was a very positive one and we look forward to using more Clojure in Beanstalk infrastructure. Who knows, maybe someday we’ll be able to speed up our deployments even further by using Clojure.</p> <h3>Interested in Clojure?</h3> <p>If you are interested in learning more about Clojure here are some great resources: </p><ul><li><a href="http://clojure.org/" rel="nofollow" target="_blank">Official Clojure web site</a></li> <li><a href="http://blip.tv/clojure" rel="nofollow" target="_blank">Clojure screencasts and presentations</a></li> <li><a href="http://clojuredocs.com" rel="nofollow" target="_blank">Clojure Docs project</a></li> <li><a href="http://4clojure.org" rel="nofollow" target="_blank">4Clojure</a> — learning Clojure interactively</li> </ul><p>Here are also some good books on the subject: <a href="http://www.manning.com/rathore/" rel="nofollow" target="_blank">Clojure in Action</a> and <a href="http://joyofclojure.com/" rel="nofollow" target="_blank">Joy of Clojure </a> from Manning, <a href="http://www.clojurebook.com/" rel="nofollow" target="_blank">Clojure Programming</a> from O’Reilly and <a href="http://pragprog.com/book/shcloj2/programming-clojure" rel="nofollow" target="_blank">Programming Clojure (2nd edition)</a> from Pragmatic Programmers.</p> <p><b>TL;DR:</b> Clojure is awesome, Beanstalk commit caching is now 20-40 times faster.</p><div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=a7UsyvOVst0:wgEaG31NWJk:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=a7UsyvOVst0:wgEaG31NWJk:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>Clojure: Freezing Time in expectations</h1> <p>2012-05-29T13:00:02+00:00</p> The current version of expectations (1.4.3) contains support for freezing time within an <a href="http://blog.jayfields.com/2011/11/clojure-expectations-scenarios.html">expectations scenario</a>. I already put this information out in a <a href="http://blog.jayfields.com/2012/05/clojure-conditionally-importing.html">previous blog entry</a>, and I'm going to use the same examples here. <br /><br />The following code is a test I was working on at work: <pre>(scenario<br /> (handle-fill (build PartialFill))<br /> (expect {:px 10 :size 33 :time 1335758400000} (first @fills)))</pre>The test builds a PartialFill domain object, and passes it to handle-fill. The handle-fill fn converts the domain object to a map and conj's the new map onto the fills vector (which is an atom). The above test would fail due to the time not being frozen, and the traditional way to deal with this issue was to change the test to use <a href="http://blog.jayfields.com/2011/11/clojure-expectations-with-values-in.html">(in ..)</a> and ignore the :time key-value pair. <br /><br />The following code would have resulted in a passing test: <pre>(scenario<br /> (handle-fill (build PartialFill))<br /> (expect {:px 10 :size 33} (in (first @fills))))</pre>The above code is fine, as long as you're not interested in verifying the time; however, things get a lot uglier if you do want to verify time. The following code freezes (joda) time, allowing for time verification: <pre>(scenario<br /> (DateTimeUtils/setCurrentMillisFixed 100)<br /> (handle-fill (build PartialFill))<br /> (expect {:px 10 :size 33 :time 100} (first @fills))<br /> (DateTimeUtils/setCurrentMillisSystem))</pre>While the above code does result in a passing test, it would cause unexpected issues if expect ever failed. In expectations a failure throws an exception (to terminate scenario execution) and the time reset would never occur. Even if that wasn't the case, the time related code takes away from the actual focus of the test. <br /><br />Therefore, expectations has been modified to take a :freeze-time parameter as part of a scenario definition. The :freeze-time parameter can be a string or a boolean - when specifying a string, anything <a href="http://joda-time.sourceforge.net/api-release/org/joda/time/DateTime.html#parse(java.lang.String)">parse-able</a> by Joda will do; if you specify a boolean time will simply be stopped at the moment of execution. <br /><br />With :freeze-time available we can rewrite the above test in the following way: <pre>(scenario<br /> :freeze-time "2012-4-30"<br /> (handle-fill (build PartialFill))<br /> (expect {:px 10 :size 33 :time 1335758400000} (first @fills)))</pre>The resulting code is easier to work with, while still allowing verification of time. <br /><br />I believe the domain related code does a better job of demonstrating the point; however, the following examples are available if you'd like something simplified. <pre>(scenario<br /> :freeze-time true<br /> (expect (DateTime.) (do (Thread/sleep 10) (DateTime.))))<br /><br />(scenario<br /> :freeze-time "2012-4-30TZ"<br /> (expect (.getMillis (DateTime.)) 1335744000000))</pre><div class="blogger-post-footer"><br /><a href="http://www.jayfields.com">© Jay Fields - www.jayfields.com</a></div><div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=1qPdxtI3VPE:ZQh53EFPQI0:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=1qPdxtI3VPE:ZQh53EFPQI0:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>The Speed Race Is On: Vert.x and Node.js</h1> <p>2012-05-29T04:53:54+00:00</p> Vert.x and Node.js are similar in some ways, and different in others. One such difference is that Node.js only allows you to write code in JavaScript whereas Vert.x allows you to code in Java, Groovy, JavaScript, Ruby and eventually as the Vert.x team expands support for the following is planned: Clojure, Scala and Python. Preview Text: ...<div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=4M3hSQl-H8w:byN8e0XK1DQ:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=4M3hSQl-H8w:byN8e0XK1DQ:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>EuroClojure 2012 – Part 2</h1> <p>2012-05-28T10:44:50+00:00</p> <p><a href="http://euroclojure.com/2012/">EuroClojure</a> for me was also about community and diversity.</p> <p>The community aspect of EuroClojure was obvious from the start. It was a great selection of friendly and welcoming people, which has always been my experience in the clojure community. During the community talk (from <a href="http://twitter.com/rrees">Robert Rees</a> and <a href="http://twitter.com/devn">Devin Walters</a>) all of the various community organisers in the room were asked to stand up and give a shout out for their group. It felt like there were a dozen or so community organisers at the event. I also know that after the talk that there are a number of new clojure communities that are going to be formed.</p> <p>Diversity overall was a mixed bag. There was good representation in the room from a number of different European countries in addition to the USA and Canada. The talks were from a mixture of professional clojurians and hobbyist clojurians. There was a good mix of ages, though no one under 20 I believe.</p> <p>I also felt, and as a programme committee member strived for, a wide variety of talks. Some of the talks were theortical, and a good number were practical. The subjects covered things in the core language, tooling, devops, art, music, maths and logic. If flights from Prague had been easier we would have also had some digital humanities in the form of computational linguistics. I also hope that there was a wide enough variety of skills needed for each of the talks from beginner through to advanced.</p> <p>As with many technical conferences we weren’t so good on racial and gender diversity. Most of the audience was white and male, though not exclusively. No women submitted talks this year. I hope to change that next year. I think we can do better and I hope to be able to follow the example of the <a href="http://openhatch.org/">OpenHatch</a> project and do more outreach overall. I think we do have a community that welcomes difference and diversity. I think we need to do more to prove it though. </p> <p>Overall, the conference was fantastic and thanks to <a href="http://twitter.com/capotribu">Marco Abis</a>. I had a great time. I survived my talk (Rich Hickey’s eye based death beams didn’t incinerate me as I had dreamed). I got to plug my startup <a href="https://www.mastodonc.com">Mastodon C</a> in my talk. I met a lot of lovely and friendly people (including Rich Hickey, who isn’t nearly so scary in real life). I also came away very enthusiastic and hopeful about the clojure community in Europe and worldwide. I’m now really looking forward to what we are all able to do over the next year.</p> <br /> <a href="http://feeds.wordpress.com/1.0/gocomments/otfrom.wordpress.com/90/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/godelicious/otfrom.wordpress.com/90/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/gofacebook/otfrom.wordpress.com/90/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/gotwitter/otfrom.wordpress.com/90/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/gostumble/otfrom.wordpress.com/90/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/godigg/otfrom.wordpress.com/90/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/goreddit/otfrom.wordpress.com/90/" rel="nofollow"></a> <div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=gGT-fzVky-w:-G3mfWQ_Ndw:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=gGT-fzVky-w:-G3mfWQ_Ndw:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>EuroClojure 2012 impressions</h1> <p>2012-05-28T09:12:57+00:00</p> <p>I just got back from the EuroClojure 2012 conference. I won't try to summarize all the talks here, just convey some general impressions that I got:</p> <ul> <li><p>Clojure community is awesome. People are incredibly nice to each other. Ask a question on the mailing list, and you'll get a number of replies from people much smarter and more experienced than you. Same at the conference: you can approach anyone and expect to get great advice even if the competence gap between you and the other person is comparable in size to the Grand Canyon.</p></li> <li><p>A lot of the talks focused on how to approach difficult and complex real-life problems better. Those weren't talks about syntactic sugar, "best practices", or new "features" the language should have. Instead, speakers presented results of months of thinking and experimenting: new architectures, new approaches, new ways to think about problems. If semicolons were discussed, it was a discussion about how to preserve them while doing source-code transformations. This is incredibly important: you can't overestimate the value of listening to smart people talk about ideas they thought hard about and developed for many months. I had several "aha!" moments where I suddenly saw that the architectures I developed were a poor-man's subset of a more general solution.</p></li> <li><p>There was a focus on building real systems. I'd say that hobbyists and academics were in the minority: most people were there to learn how to better build code that makes money. It was also interesing to see the range of sizes of companies that use Clojure: from one-person consultancies through startups and small web-development shops, all the way through large financial institutions.</p></li> <li><p>The median age of participants was probably between 35 and 40 years. This is clearly not a bunch of teenagers, but rather a group that gained significant experience in various languages and then moved on to Clojure. I think this has a lot to do with my first point — the community is both incredibly nice and mature, which often go together.</p></li> </ul> <p>Overall, the conference was a success — more so than I expected. The organization was nearly flawless (not an easy task, I know, so hats off to Marco Abis). And it is now very clear than a European conference about Clojure is necessary. I'm looking forward to EuroClojure 2013!</p><div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=z0rZ5jurpsk:CSGcuTJj0d0:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=z0rZ5jurpsk:CSGcuTJj0d0:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>clojure: type hinting and warn on reflection</h1> <p>2012-05-28T04:54:11+00:00</p> <p> I've been working a bit with the javax.sound.midi libraries, using clojure. I just ran across a problem I hadn't encountered before, so I wanted to share the solution. If you are a clojure veteran, this post won't be interesting, but if you're new to the language like me (or googling the error I got), it might help. </p><p> Quick MIDI background. A synthesizer is something you can use to generate sound. A Synthesizer has one or more channels, which you use to generate the sound. For a real world analogy, a Synthesizer is like a piano, and a channel is like your left hand. </p><p> I was executing some fairly basic clojure code: </p> <pre>(import 'javax.sound.midi.Synthesizer 'javax.sound.midi.MidiSystem) (def synth (doto (MidiSystem/getSynthesizer) .open)) (aget (.getChannels synth) 0) IllegalArgumentException Can't call public method of non-public class: public javax.sound.midi.MidiChannel[] com.sun.media.sound.AbstractPlayer.getChannels() clojure.lang.Reflector.invokeMatchingMethod (Reflector.java:87) </pre> <p> Hey, what's going on here? According to the <a href="http://docs.oracle.com/javase/7/docs/api/javax/sound/midi/Synthesizer.html">javadoc</a>, Synthesizer.getChannels() is fair game! </p> <p>The problem is caused by the fact that clojure's java interoperability works by reflection, and in this case, it's getting confused as to what type the class is. Since this is a common problem, clojure provides a mechanism, <a href="http://clojure.org/java_interop#Java%20Interop-Type%20Hints">type hinting</a>, to help deal. There is also a flag you can set to be notified of potential errors of this type, <a href="http://clojuredocs.org/clojure_core/clojure.core/*warn-on-reflection*">warn-on-reflection</a>. So, all I had to do to fix this, was let clojure know what type it should be using to call .getChannels(), using a type hint: </p> <pre>(aget (.getChannels ^Synthesizer synth) 0) # </pre> <p> voila! also, setting *warn-on-reflection* allows us to see what's happening here: </p> <pre>(set! *warn-on-reflection* true) true user=> (aget (.getChannels synth) 0) Reflection warning, NO_SOURCE_PATH:7 - reference to field getChannels can't be resolved. </pre><div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=kDF2ifojlZ8:SRznZNhYVOg:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=kDF2ifojlZ8:SRznZNhYVOg:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>Ruby Clojure Integration</h1> <p>2012-05-28T02:10:07+00:00</p> <p>Lately I’ve been looking into the Clojure programming language, a Lisp that’s implemented on top of the JVM. One of the aspects of Clojure that I’m interested in is its ability to integrate into existing projects, especially Ruby projects. Since Clojure runs on the JVM and already <a href="http://clojure.org/java_interop" rel="nofollow" target="_blank">integrates with Java</a> it should be easy to integrate into a Ruby project run on JRuby. I discovered the JRuby Clojure Bridge gem, called <a href="https://github.com/kyleburton/jrclj" rel="nofollow" target="_blank">jrclj</a>, that does just that.</p> <h2>Demonstration</h2> <p>I’ve created a test project that demonstrates using jrclj. It’s on <a href="https://github.com/jasongilman/jruby_clojure_integration_demo" rel="nofollow" target="_blank">github</a>. Follow the directions in the <a href="https://github.com/jasongilman/jruby_clojure_integration_demo/blob/master/README.md" rel="nofollow" target="_blank">README</a> to try it out. It consists of a small Clojure project, powers_of_two, and a Ruby file that demonstrates calling the powers_of_two code. </p> <h2>The Clojure Code</h2> <p>The main source code for powers_of_two is in one source file, <a href="https://github.com/jasongilman/jruby_clojure_integration_demo/blob/master/powers_of_two/src/powers_of_two/core.clj" rel="nofollow" target="_blank">core.clj</a></p> <pre>(ns powers_of_two.core) (defn powers_of_two ([] (concat [1 2 4] (powers_of_two 4N))) ([last_value] (let [next_value (* last_value 2N)] (lazy-seq (cons next_value (powers_of_two next_value)))))) (defn powers_of_two_improved [] (iterate (fn [v] (* v 2N)) 1)) </pre> <p>core.clj contains two functions that do the same thing, return a sequence of numbers containing the powers of two. ie. 2^0, 2^1, 2^2, 2^3,… or 1, 2, 4, 8, … The sequences are recursively infinite but use <code>lazy-seq</code> to avoid recursing forever. Lazy sequences in Clojure give you the power of defining a sequence of things (numbers, database records, dates, etc) recursively and infinitely. The first <code>powers_of_two</code> function does it manually using recursion and the <a href="http://clojuredocs.org/clojure_core/clojure.core/lazy-seq" rel="nofollow" target="_blank">lazy-seq function</a>. The <code>powers_of_two_improved</code> function uses the <code><a href="http://clojuredocs.org/clojure_core/clojure.core/iterate" rel="nofollow" target="_blank">iterate</a></code> function, which lets you build a lazy sequence from a function and a starting value. The upper case <code>N</code> in the examples after numbers changes them to Clojure big integers. The powers of two sequence will quickly grow beyond what a normal integer can represent.</p> <h2>The Ruby Code</h2> <p>The <a href="https://github.com/jasongilman/jruby_clojure_integration_demo/blob/master/use_powers_of_two.rb" rel="nofollow" target="_blank">use_powers_of_two.rb script</a> demonstrates calling Clojure from JRuby</p> <pre>require 'rubygems' require 'java' # Require the clojure jars require 'powers_of_two/lib/clojure-1.4.0.jar' require 'powers_of_two/lib/clojure-contrib-1.2.0.jar' # Require the project jar that we want to use require 'powers_of_two/powers_of_two-1.0.0-SNAPSHOT.jar' # Require the jrclj gem that lets us interact with clojure code require 'jrclj' # Create a JRClj context. We can then import clojure namespaces which will make the functions available clj = JRClj.new clj._import "powers_of_two.core" puts "2**500 == " + clj.nth(clj.powers_of_two, 500).to_s </pre> <p>The last line actually makes the call into Clojure. It calls the Clojure function <code><a href="http://clojuredocs.org/clojure_core/clojure.core/nth" rel="nofollow" target="_blank">nth</a></code> which will take the 500th item from the sequence returned by the <code>powers_of_two</code> function. This prints out 2^500.</p> <h2>Repl</h2> <p>You can try out a repl with jruby clojure integration using the jrepl script included in the project. Run jrepl from a command line and then try the following bits of code</p> <p><code>./jrepl<br /> Your .irbrc has loaded<br /> >> clj.powers_of_two<br /> => #<Java::ClojureLang::LazySeq:0x1558473e></code><br /> powers_of_two just returns a lazy sequence</p> <p><code>>> clj.take( 10, clj.powers_of_two).map(&:to_i)<br /> => [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]</code><br /> This takes the first 10 items from the Clojure sequence. We then use Ruby’s map method to convert all of the results to integers. The Ruby map method works on lazy sequences from Clojure because one of it’s interfaces is standard Java interface <code>java.util.List</code>. JRuby allows <code>java.util.List</code>s to be treated like Ruby Arrays. This means the Clojure sequences themselves can be accessed like a Ruby array.</p> <p><code>>> clj.powers_of_two.map(&:to_i)<br /> NativeException: java.lang.OutOfMemoryError: Java heap space</code><br /> The Clojure sequences are infinite. If you’re not careful you can run out of memory.</p> <h2>Why?</h2> <p>So why would you want to integrate Clojure with Ruby? It would certainly be simpler to limit your projects to a single language. Clojure has benefits that are worth exploring. Clojure makes it very easy to write concurrent code that perform well. Functions that don’t manipulate state and minimize or have no side effects are easier to understand and test. Macros (http://clojure.org/macros) are like metaprogramming on steroids. There are also libraries built in Clojure that would be useful to integrate into a Ruby project. An example of this is <a href="http://incanter.org/" rel="nofollow" target="_blank" title="Incanter">Incanter</a>, a platform for statistical computing and graphics. The fact that Clojure integrates so easily with JRuby makes it easy to experiment.</p><div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=PYKZPP8MJz4:zZ4gcl_OrDY:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=PYKZPP8MJz4:zZ4gcl_OrDY:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>EuroClojure Day 2</h1> <p>2012-05-27T22:57:40+00:00</p> <p>Okay so this post maybe happening a little later than Friday but in my defence there were some excellent conversations to go with the after-conference drinks.</p> <p>Day 2 featured two talks by Rich Hickey, I had already seen some of the Datomic stuff from QCon and the web so I found the stuff on the new reducers library more engaging. I have never thought of map having an implicit ordering promise.</p> <p><a href="http://euroclojure.com/2012/speakers/#Meikel_Brandmeyer">Meikel Brandmeyer</a> gave a historical review of lazy seq which was really helpful for understanding laziness (something I have a bit of a problem with). One of the real highlights though was Chris Ford’s talk about <a href="https://github.com/ctford/goldberg">canon music</a>. It started with a good gag about sheet music being a DSL for using the finite state machine otherwise known as a musician. However the really amazing thing was Chris’s abstraction of the score and subsequent transformations of the abstract score to end up with variations on the base canon he had chosen. Really amazing. Chris’s talk really shouldn’t have been a lightning talk, it is about the only quibble I had with the programming.</p> <p>Sam Newman also had an excellent closing line in his lightning talk on Riemann, which was if people want Clojure to be adopted widely then the secret is to create great things with Clojure.</p> <br /> <a href="http://feeds.wordpress.com/1.0/gocomments/rrees.wordpress.com/829/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/godelicious/rrees.wordpress.com/829/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/gofacebook/rrees.wordpress.com/829/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/gotwitter/rrees.wordpress.com/829/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/gostumble/rrees.wordpress.com/829/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/godigg/rrees.wordpress.com/829/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/goreddit/rrees.wordpress.com/829/" rel="nofollow"></a> <div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=HXrgVLLiYS0:5FuW_4Isw-E:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=HXrgVLLiYS0:5FuW_4Isw-E:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>Reflections on Euroclojure</h1> <p>2012-05-27T19:58:41+00:00</p> <p>I spent Thursday and Friday last week attending the first <a href="http://www.clojure.org/" target="_blank" title="The Clojure website">Clojure</a> conference outside of the US – <a href="http://euroclojure.com/2012/" target="_blank" title="Euroclojure 2012">Euroclojure</a> – in London. I’ve got to say that I’ve come back feeling really excited by what I saw there.</p> <p>I’ve been to many conferences before and this one was quite small in comparison with those. However, with 200 enthusiastic coders from the UK, Europe, the US and Canada, it was a really great and friendly place to be. More importantly there were plenty of great ideas talked about as well.</p> <p>Clojure is a really exciting young language. It’s embracement of the Java and the JVM has allowed many at the conference to bring in elegant solutions to existing legacy (Java) software without wholesale rewrites. In every case this has been achieved with less code and faster results. That has to be great news!</p> <p>Better still was hearing about the things that are really fresh and new such as experimenting with dynamic programming of music in <a href="http://overtone.github.com/" target="_blank" title="Overtone - Making music in Clojure">Overtone</a> (like modifying waveforms in real time to see how the sound is affected) or demonstrating JS Bach’s Canons in Overtone or dynamic algorithmic <a href="http://www.cassiel.com/" target="_blank" title="Nick Rothwell's art with Clojure">art displays</a> using Clojure. Not that programming is just about art! There were also great talks on logic programming, solving concurrency issues in databases with <a href="http://datomic.com/" target="_blank">Datomic</a>, automating deployments in the Cloud with <a href="http://palletops.com/" target="_blank">Pallet</a>, and data processing in Hadoop with <a href="http://nathanmarz.com/blog/introducing-cascalog-a-clojure-based-query-language-for-hado.html" target="_blank" title="Cascalog for data processing on Hadoop with Clojure">Cascalog</a> to name a few.</p> <p>So many talks in such a small amount of time was pretty mind blowing, especially given the heat, but meeting so many great people was fantastic. Roll on Euroclojure 2013!</p> <br /> <a href="http://feeds.wordpress.com/1.0/gocomments/simonholgate.wordpress.com/33/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/godelicious/simonholgate.wordpress.com/33/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/gofacebook/simonholgate.wordpress.com/33/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/gotwitter/simonholgate.wordpress.com/33/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/gostumble/simonholgate.wordpress.com/33/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/godigg/simonholgate.wordpress.com/33/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/goreddit/simonholgate.wordpress.com/33/" rel="nofollow"></a> <div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=Tmvj8o15RiU:rCMa_Z-zMbY:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=Tmvj8o15RiU:rCMa_Z-zMbY:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>Project Euler in Clojure – Problem 3</h1> <p>2012-05-27T19:37:28+00:00</p> <p>In trying to learn Clojure and wrap my head around good functional programming, and hoping to learn more idiomatic Clojure, I have started working through the Project Euler problems. In doing this, I have also setup a repository on <a href="http://www.github.com">github.com</a> to keep track of my progress, which can be found at <a href="https://github.com/stevenproctor/project-euler-clojure">https://github.com/stevenproctor/project-euler-clojure</a>. My approach to Problem 2 can be found <a href="http://proctorit.wordpress.com/2012/05/27/project-euler-in-clojure-problem-2/" title="Project Euler in Clojure – Problem 2">here</a>.</p> <p><a href="http://projecteuler.net/problem=3">Problem 3</a> of Project Euler is described as:</p> <pre>What is the largest prime factor of the number 600851475143 ?</pre> <p>For this problem, I needed to generate the prime factors of a number. In order to generate the prime factors, I decided to pul out the Uncle Bob’s (found <a href="https://twitter.com/unclebobmartin">here</a>, <a href="http://blog.8thlight.com/uncle-bob/archive.html">here</a>, <a href="http://blog.objectmentor.com/articles/category/uncle-bobs-blatherings">here</a>, and <a href="http://butunclebob.com/ArticleS.UncleBob">here</a>) <a href="http://www.viddler.com/v/17023668">Prime Factors Kata</a> and apply it to Clojure. By doing this kata, I test drove the result, and decided I would give <a href="http://www.exampler.com/blog/">Brian Marick’s</a> <a href="https://github.com/marick/Midje">Midje</a> a shot and play with that some as well. The resulting tests are as follows.</p> <p></p><pre class="brush: clojure;">(ns project-euler.prime-factors-test (:use clojure.test midje.sweet project-euler.core)) (defn mersenne [n] (int (dec (Math/pow 2 n)))) (fact (prime-factors-of 1) => [] (prime-factors-of 2) => [2] (prime-factors-of 3) => [3] (prime-factors-of 4) => [2 2] (prime-factors-of 5) => [5] (prime-factors-of 6) => [2 3] (prime-factors-of 7) => [7] (prime-factors-of 8) => [2 2 2] (prime-factors-of 9) => [3 3] (prime-factors-of 10) => [2 5] (prime-factors-of 11) => [11] (prime-factors-of 12) => [2 2 3] (prime-factors-of 16) => [2 2 2 2] (prime-factors-of 25) => [5 5] (prime-factors-of (* 2 3 5 7 11 17 37)) => [2 3 5 7 11 17 37] (prime-factors-of (mersenne 17)) => [(mersenne 17)]) </pre><p></p> <p>The total solution to problem 3 is as follows, with the test driven function for generating the prime factors, is:</p> <p></p><pre class="brush: clojure;">(defn factors-starting-at [f n] (cond (= n 1) [] (zero? (rem n f)) (cons f (factors-starting-at f (/ n f))) :else (recur (inc f) n))) (defn prime-factors-of [n] (factors-starting-at 2 n)) (defn problem3 [] (reduce max (prime-factors-of 600851475143))) </pre><p></p> <p>The resulting function for prime-factors-of calls the recursive function factors-starting-at with the first factor of 2, and the number itself. The factors-starting-at returns an empty vector when n is one. When the factor is actually a factor of the number (zero? (rem n f)) the returned result is the factor cons’ed onto the result of calling factors-starting-at again with the same factor, and the number divided by that factor. Otherwise, we return the result of recur-ing with the same number and the factor incremented again.</p> <p>The solution to problem 3 is actually very simple in Clojure after one generates the prime factors for a number. All that one has to do is reduce the sequence of prime factors with the function max to find the largest prime factor for the number 600851475143.</p> <p>I would love comments and suggestions on my solution to this problem, and if there are tweaks to make it more Clojure-ish.</p> <p>–Proctor</p> <br />Filed under: <a href="http://proctorit.wordpress.com/category/clojure/">Clojure</a>, <a href="http://proctorit.wordpress.com/category/deliberate-practice/">Deliberate Practice</a>, <a href="http://proctorit.wordpress.com/category/lisp/">Lisp</a>, <a href="http://proctorit.wordpress.com/category/project-euler/">Project Euler</a> Tagged: <a href="http://proctorit.wordpress.com/tag/clojure/">Clojure</a>, <a href="http://proctorit.wordpress.com/tag/deliberate-practice/">Deliberate Practice</a>, <a href="http://proctorit.wordpress.com/tag/project-euler/">Project Euler</a> <a href="http://feeds.wordpress.com/1.0/gocomments/proctorit.wordpress.com/144/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/godelicious/proctorit.wordpress.com/144/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/gofacebook/proctorit.wordpress.com/144/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/gotwitter/proctorit.wordpress.com/144/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/gostumble/proctorit.wordpress.com/144/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/godigg/proctorit.wordpress.com/144/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/goreddit/proctorit.wordpress.com/144/" rel="nofollow"></a> <div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=qwGaLionXig:LM-7Kpbxs7A:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=qwGaLionXig:LM-7Kpbxs7A:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>Project Euler in Clojure – Problem 2</h1> <p>2012-05-27T19:04:05+00:00</p> <p>In trying to learn Clojure and wrap my head around good functional programming, and hoping to learn more idiomatic Clojure, I have started working through the Project Euler problems. In doing this, I have also setup a repository on <a href="http://www.github.com">github.com</a> to keep track of my progress, which can be found at <a href="https://github.com/stevenproctor/project-euler-clojure">https://github.com/stevenproctor/project-euler-clojure</a>. My approach to Problem 1 can be found <a href="http://proctorit.wordpress.com/2012/05/27/project-euler-in-clojure-problem-1/" title="Project Euler in Clojure – Problem 1">here</a>.</p> <p><a href="http://projecteuler.net/problem=2">Problem 2</a> of Project Euler is described as:</p> <pre>By considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms.</pre> <p>The solution I came up with is:</p> <p></p><pre class="brush: clojure;">(defn skip-n [n s] (cond (<= n 0) s :else (recur (dec n) (rest s)))) (defn fib ([] (concat [0N 1N] (fib 0N 1N))) ([a b] (let [c (+ a b)] (lazy-seq (cons c (fib b c)))))) (defn problem2 [] (reduce + (filter #(even? %) (take-while #(< % 4000000N) (skip-n 2 (fib)))))) </pre><p></p> <p>As a didn’t see a skip function, which would keep a sequence, but skip over a given number of inputs, I created the function skip-n. The skip function calls the function rest on the sequence n number of times by using recur, and decrementing n.</p> <p>The function fib generates the Fibonacci sequence lazily by using the function lazy-seq to create a lazily evaluated sequence, as I want the numbers generated until the time that I decide I do not need them anymore. Instead of trying to determine how many that will be before I generate them, I just decided to make them generated lazily.</p> <p>The previous two functions were a helper function, and the function to generate the Fibonacci sequence (huh, sequence is even in the name). The work to determine the results of the problem are found in the function problem2. This function uses the skip-n function to skip the first two results, as Project Euler shows the Fibonacci sequence starting as 1, 2, 3, … instead of the starting as 0, 1, 1, 2, 3, … so I skip the first two in the sequence. I then use the take-while function to take only those items which are less than 4 million, which I then feed to the filter function to take only those items from the Fibonacci sequence that are even. The last step is to use the reduce function to sum all of those items together to get the final result.</p> <p>I would love comments and suggestions on my solution to this problem, and if there are tweaks to make it more Clojure-ish.</p> <p><strong>**Updated**</strong><br /> Here is my approach to <a href="http://proctorit.wordpress.com/2012/05/27/project-euler-in-clojure-problem-3/" title="Project Euler in Clojure – Problem 3">Problem 3 in Clojure.</a></p> <p>–Proctor</p> <br />Filed under: <a href="http://proctorit.wordpress.com/category/clojure/">Clojure</a>, <a href="http://proctorit.wordpress.com/category/deliberate-practice/">Deliberate Practice</a>, <a href="http://proctorit.wordpress.com/category/lisp/">Lisp</a>, <a href="http://proctorit.wordpress.com/category/project-euler/">Project Euler</a> Tagged: <a href="http://proctorit.wordpress.com/tag/clojure/">Clojure</a>, <a href="http://proctorit.wordpress.com/tag/deliberate-practice/">Deliberate Practice</a>, <a href="http://proctorit.wordpress.com/tag/project-euler/">Project Euler</a> <a href="http://feeds.wordpress.com/1.0/gocomments/proctorit.wordpress.com/137/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/godelicious/proctorit.wordpress.com/137/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/gofacebook/proctorit.wordpress.com/137/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/gotwitter/proctorit.wordpress.com/137/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/gostumble/proctorit.wordpress.com/137/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/godigg/proctorit.wordpress.com/137/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/goreddit/proctorit.wordpress.com/137/" rel="nofollow"></a> <div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=EhxbvMAJ9FE:pf4vwu6A5pg:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=EhxbvMAJ9FE:pf4vwu6A5pg:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>EuroClojure 2012 – Part 1</h1> <p>2012-05-27T19:01:09+00:00</p> <p>At the end of a very busy week was the highlight for me. <a href="http://euroclojure.com/2012/">EuroClojure</a> 2012 was a chance to gather about 250 clojurians from Europe and further afield. There were keynotes from Stuart Halloway and Rich Hickey. Due to one speaker not being able to make it there was an extra talk from Rich Hickey so we heard more about the new <a href="http://clojure.com/blog/2012/05/15/anatomy-of-reducer.html" title="Reducers">Reducers</a> library and <a href="http://datomic.com/" title="Datomic">Datomic</a>. I gave a talk on <a href="https://github.com/liebke/incanter" title="Incanter">Incanter</a>. The code and presentation for that can be found on my <a href="https://github.com/otfrom/quiddswic">github repo</a>. </p> <p>Here are a few of the highlights for me.</p> <p><a href="https://twitter.com/#!/sthuebner">Stefan Hübner</a> gave a great talk on <a href="https://github.com/nathanmarz/cascalog/wiki">Cascalog</a>. I love the idea of having a query language for local data, random bits of data and things on disk and in memory all the way up to a hadoop cluster. While Datomic looks really cool to play with once you have your data together, Cascalog looks like a great way of getting that data into a reasonable format.</p> <p><a href="http://twitter.com/pingles">Paul Ingles</a> talk on Users as Data fit into this. What I took away was how lossy data warehouses are. Keeping as much data about user events (similar to the CQRS/eve(nt) talk from <a href="http://euroclojure.com/2012/speakers/#Max_Weber">Max Weber</a>). I’d love to have everything in Datomic, but I know I live in a messier world than that, so I’ll always end up using something like Cascalog. Events were again central to <a href="http://euroclojure.com/2012/speakers/#Zach_Tellman">Zach Tellman’s</a> talk on <a href="https://github.com/ztellman/lamina">lamina</a>.</p> <br /> <a href="http://feeds.wordpress.com/1.0/gocomments/otfrom.wordpress.com/74/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/godelicious/otfrom.wordpress.com/74/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/gofacebook/otfrom.wordpress.com/74/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/gotwitter/otfrom.wordpress.com/74/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/gostumble/otfrom.wordpress.com/74/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/godigg/otfrom.wordpress.com/74/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/goreddit/otfrom.wordpress.com/74/" rel="nofollow"></a> <div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=Pkl6cKJFs4o:B1vnYst6AYM:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=Pkl6cKJFs4o:B1vnYst6AYM:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>EuroClojure 2012</h1> <p>2012-05-27T13:59:20+00:00</p> <span style="font-family: 'Helvetica Neue', Arial, Helvetica, sans-serif;">WOW... </span><br /><span style="font-family: 'Helvetica Neue', Arial, Helvetica, sans-serif;"><br /></span><br /><span style="font-family: 'Helvetica Neue', Arial, Helvetica, sans-serif;"><a href="http://euroclojure.com/2012/" target="_blank">EuroClojure 2012</a> ended Friday and what an excellent conference it was. As <a href="http://twitter.com/#!/stuarthalloway" target="_blank">Stuart Halloway</a> said: the hottest conference in Europe. Lots of interesting talks, lots of performances and even more interesting people. I talked to people from all over Europe and there were even quite a few people from the US, not just the <a href="http://thinkrelevance.com/" target="_blank">Relevance</a> folks. A few things that stuck:</span><br /><br /><ul><li><span style="font-family: 'Helvetica Neue', Arial, Helvetica, sans-serif;">Thanks to HOF one can burn 400 of the 600 pages of the GoF book</span></li><li><span style="font-family: 'Helvetica Neue', Arial, Helvetica, sans-serif;">Keep track of events, not states</span></li><li><span style="font-family: 'Helvetica Neue', Arial, Helvetica, sans-serif;"><a href="https://github.com/overtone" target="_blank">Overtone</a> is extremely cool</span></li><li><span style="font-family: 'Helvetica Neue', Arial, Helvetica, sans-serif;"><a href="https://github.com/ctford/goldberg" target="_blank">Bach</a> was a functional programmer ;)</span></li><li><span style="font-family: 'Helvetica Neue', Arial, Helvetica, sans-serif;">I really should try the new reducer framework</span></li><li><span style="font-family: 'Helvetica Neue', Arial, Helvetica, sans-serif;">More Clojure in general</span></li><li><span style="font-family: 'Helvetica Neue', Arial, Helvetica, sans-serif;">We are definitely going to start a Hampshire Clojurians group</span></li><li><span style="font-family: 'Helvetica Neue', Arial, Helvetica, sans-serif;">Rich Hickey is a really nice guy (Just like all the other Clojurians)</span></li></ul><div><span style="font-family: 'Helvetica Neue', Arial, Helvetica, sans-serif;">I hope to see everyone again next year!!!</span></div><div><span style="font-family: 'Helvetica Neue', Arial, Helvetica, sans-serif;"><br /></span></div><div><span style="font-family: 'Helvetica Neue', Arial, Helvetica, sans-serif;">ps. and Marco is an excellent event organiser, thank you.</span></div><div class="blogger-post-footer"></div><div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=Iiz-u-jUYDw:jJx38ZcYAfo:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=Iiz-u-jUYDw:jJx38ZcYAfo:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>My first Clojure macro</h1> <p>2012-05-27T13:13:00+00:00</p> <p>is <code>macro?</code>:</p> <pre><code>(defmacro macro? [form] "Return true if form is a macro." `(:macro (meta #'~form) false)) </code></pre> <p>Use case: I am new to the language, and don’t know yet when to quote arguments. With <code>macro?</code> and the REPL it’s quick to learn. Example:</p> <pre><code>user=> (macro? macro?) true user=> (macro? next) false </code></pre> <p>It’s funny that to operate on macros you need a (read-time) macro.</p><div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=38pEPo48yho:1oztPL-rjdU:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=38pEPo48yho:1oztPL-rjdU:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>No such pipe, or this pipe has been deleted</h1> <p>2012-05-27T05:19:18+00:00</p> This data comes from pipes.yahoo.com but the Pipe does not exist or has been deleted.<div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=Ro2eosQjYao:rhfMXPWh33k:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=Ro2eosQjYao:rhfMXPWh33k:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>No such pipe, or this pipe has been deleted</h1> <p>2012-05-27T05:16:39+00:00</p> This data comes from pipes.yahoo.com but the Pipe does not exist or has been deleted.<div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=Ro2eosQjYao:NPscWKkLZck:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=Ro2eosQjYao:NPscWKkLZck:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>No such pipe, or this pipe has been deleted</h1> <p>2012-05-27T05:15:18+00:00</p> This data comes from pipes.yahoo.com but the Pipe does not exist or has been deleted.<div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=Ro2eosQjYao:qAtxPMuP3Eg:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=Ro2eosQjYao:qAtxPMuP3Eg:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>No such pipe, or this pipe has been deleted</h1> <p>2012-05-27T05:12:46+00:00</p> This data comes from pipes.yahoo.com but the Pipe does not exist or has been deleted.<div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=Ro2eosQjYao:uUxTIBDR9PM:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=Ro2eosQjYao:uUxTIBDR9PM:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>No such pipe, or this pipe has been deleted</h1> <p>2012-05-27T05:07:34+00:00</p> This data comes from pipes.yahoo.com but the Pipe does not exist or has been deleted.<div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=Ro2eosQjYao:NyGJQY2I6_U:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=Ro2eosQjYao:NyGJQY2I6_U:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>EuroClojure Wrapup</h1> <p>2012-05-26T13:57:00+00:00</p> [Edit: So I accidentally published this a bit early, and I've only now had time to get home and add a bit of polish and details that were lacking, so if you read an earlier version, the content is very slightly different now.] I’m just back from the first European Clojure conference in London, [...]<div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=1ZaaBnHq3WQ:EROi9ec2iE8:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=1ZaaBnHq3WQ:EROi9ec2iE8:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>Pitch and Frequency</h1> <p>2012-05-26T10:39:00+00:00</p> <p> </p><p>I’ve just come back from <a href="http://euroclojure.com/2012/">EuroClojure 2012</a>, where there were a number of Overtone talks and a number of tweets asking for music theory resources aimed at computer scientists. This will hopefully blog number 1 in a series on that theme.</p> <p>Note that the code examples are designed to be pasted into a Clojure repl, so that you can take the code and play with it yourself.</p> <hr /> <p>The basic atoms of synthesizing sounds in Overtone are oscillators. An oscillator takes a frequency and makes a noise. Here are some examples:</p> <div class="CodeRay"> <div class="code"><pre>(use 'overtone.live) (demo (sin-osc 440)) ; sine wave (demo (saw 440)) ; saw-tooth wave (demo (square 440)) ; square wave</pre></div> </div> <p>In each of these, we’re making an oscillator and giving it a frequency of 440 Hz — or equivalently, 440 cycles per second (cps). The problem we find is that most music isn’t defined in terms of frequency, it’s defined in terms of notes of the scale: C D E F G A B C and all the sharps and flats in between. How do we play a tune on a sine wave generator when the tune is made of notes rather than frequencies?</p> <p>First, let’s write some helpers to play a sequence of frequencies through a sine wave:</p> <div class="CodeRay"> <div class="code"><pre>(definst sine-wave [freq 440] (sin-osc freq)) ;=> #<instrument: sine-wave> (defn play-freqs ([freqs] (play-freqs freqs (now) (sine-wave (first freqs)))) ([freqs time inst] (if-let [freqs (seq freqs)] (do (at time (ctl (:id inst) :freq (first freqs))) (apply-at (+ time 300) #'play-freqs [(rest freqs) (+ time 300) inst])) (at time (kill (:id inst)))))) ;=> #'user/play-freqs (play-freqs [440 660 330 440 220 880 220]) ; *beautiful melody* ;=> #<ScheduledJob id: 76, created-at: Sat 09:32:26s, initial-delay: 0, desc: "Overtone delayed fn", scheduled? false></pre></div> </div> <p>We define a simple intrument, <code>sine-wave</code>, which has one parameter, <code>freq</code>. We can start the instrument with a particular frequency by writing <code>(sine-wave 440)</code>; this returns a map of data about the particular oscillator instance which is generating the note. We can change the freq parameter of a running instrument by using <code>(ctl (:id inst) :freq 660)</code>. Finally, we can stop a running inst with <code>(kill (:id inst))</code>. (And if it all goes horribly wrong, we can stop absolutely everything with <code>(stop)</code>).</p> <p>Our goal is to be able to use <code>play-freqs</code> to play tunes made of keywords rather than frequencies: <code>[:c4 :d4 :e4 :d4 :c4]</code>.</p> <h2>Frequency of notes from first principles</h2> <p>You can calculate frequency from pitch using only four fundamental axioms:</p> <ol> <li>When an orchestra tunes up at the start of a rehearsal, they tune to A. A is normally defined to be 440 Hz.</li> <li>Going up one octave is the same as doubling the frequency. That is, one octave above tuning A is 880 Hz, and one octave below is 220 Hz.</li> <li>There are twelve semitones in an octave.</li> <li>All semitones are equally sized.</li> </ol> <p>If going up an octave doubles the frequency, then going up twelve semitones must also double the frequency. This means we must find the number <code>semitone</code>, where:</p> <div class="CodeRay"> <div class="code"><pre>(nth (iterate #(* semitone %) 440) 12) ;=> 880</pre></div> </div> <p>In other words, we want <code>semitone^12 == 2</code>, so semitone must be the twelfth root of 2:</p> <div class="CodeRay"> <div class="code"><pre>; from the contrib library [org.clojure/math.numeric-tower "0.0.1"] (require '([clojure.math.numeric-tower :as 'math])) ;=> nil (def semitone (math/expt 2 1/12)) ;=> #'user/semitone (nth (iterate #(* semitone %) 440) 12) ;=> 880.0000000000003 ; or alternatively: (* (math/expt semitone 12) 440) ;=> 880.0000000000003</pre></div> </div> <p>We can now define a function to find a frequency a given number of semitones from tuning A:</p> <div class="CodeRay"> <div class="code"><pre>(defn semitones-from-a [semis] (* (math/expt semitone semis) 440)) ;=> #'user/semitones-from-a (semitones-from-a 0) ;=> 440.0 (semitones-from-a 12) ;=> 880.0000000000003 (semitones-from-a 3) ;=> 523.2511306011974 (semitones-from-a -9) ;=> 261.6255653005985</pre></div> </div> <p>Normally, however, we use MIDI notes as a numerical representation of notes, rather than displacement from tuning A. In the MIDI note system, tuning A is defined to be 69, and going up or down one semitone increases or decreases the note value by one. So, for example, middle C is 60. We can get from midi notes to frequencies like this:</p> <div class="CodeRay"> <div class="code"><pre>(defn midi-to-hz [midi-note] (semitones-from-a (- midi-note 69))) ;=> #'user/midi-to-hz (midi-to-hz 69) ;=> 440.0 (midi-to-hz 81) ;=> 880.0000000000003 (midi-to-hz 72) ;=> 523.2511306011974 (midi-to-hz 60) ;=> 261.6255653005985</pre></div> </div> <p>In fact, Overtone provides a function <code>midi->hz</code> to do exactly this transformation:</p> <div class="CodeRay"> <div class="code"><pre>(midi->hz 69) ;=> 440.0 (midi->hz 81) ;=> 880.0 (midi->hz 72) ;=> 523.2511306011972 (midi->hz 60) ;=> 261.6255653005986</pre></div> </div> <p>So with a melody as MIDI notes, we can play it as follows:</p> <div class="CodeRay"> <div class="code"><pre>(play-freqs (map midi->hz [60 62 64 62 60 72 67 60]))</pre></div> </div> <hr /> <p>If you’ve got this far, the maths is over. The last mile is to be able to use keywords instead of raw MIDI values. Overtone provides a function for this called <code>note</code>:</p> <div class="CodeRay"> <div class="code"><pre>(note :a4) ;=> 69 (note :a5) ;=> 81 (note :c5) ;=> 72 (note :c4) ;=> 60</pre></div> </div> <p>So we can play our tune by chaining this with <code>midi->hz</code>:</p> <div class="CodeRay"> <div class="code"><pre>(play-freqs (map (comp midi->hz note) [:c4 :c5 :e4 :f4 :g4 :f4 :e4 :d4 :c4 :c4])) ; *beautiful music*</pre></div> </div> <p></p> <p><a href="http://rhebus.posterous.com/pitch-and-frequency">Permalink</a> | <a href="http://rhebus.posterous.com/pitch-and-frequency#comment">Leave a comment »</a> </p><div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=Ir5dJKdTqSw:kxeOE35331k:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=Ir5dJKdTqSw:kxeOE35331k:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>Navigate to Definition or F3 in Eclipse counterclockwise</h1> <p>2012-05-25T22:44:46+00:00</p> <p>I believe I lost many people’s attention during my live coding sessions with <a href="http://clojure.org" rel="nofollow" target="_blank">Clojure</a> and the Eclipse plugin for Clojure development – <a href="http://code.google.com/p/counterclockwise/" rel="nofollow" target="_blank">counterclockwise</a> as I used to not get the feature <strong>Navigate to Definition</strong> or just hovering over a symbol with the Cmd key working in Eclipse.</p> <p><a href="http://blog.japila.pl/wp-content/uploads/2012/05/eclipse-clojure-navigate-to-definition.png" rel="nofollow" target="_blank"></a></p> <p>I didn’t care much as Eclipse was an IDE that I didn’t spend much time with while developing applications in Clojure. It was Clojure’s REPL where I spent most of the time. On the other hand, I was asked to show the IDE support for Clojure and Eclipse was presented.</p> <p>Whenever I hovered over a symbol the error message <strong>“You need a running Clojure VM”</strong> was shown.</p> <p><a href="http://blog.japila.pl/wp-content/uploads/2012/05/eclipse-clojure-you-need-a-running-clojure-vm.png" rel="nofollow" target="_blank"></a></p> <p>I couldn’t fix it for long time until today.</p> <p>Have all the dependencies of your Clojure project defined in Eclipse. I use <a href="http://leiningen.org" rel="nofollow" target="_blank">leiningen 2</a> which used to download the dependencies into <strong>lib</strong> and <strong>lib/dev</strong> directories (in the version 1), but it doesn’t anymore so I had to use the <strong>pom</strong> task which <em>“Writes a pom.xml file to disk for Maven interoperability.”</em> (from <strong>lein2 help pom</strong>).</p> <p>Once <strong>pom.xml</strong> is generated, import the project into Eclipse using <strong>Import > Maven > Existing Maven Projects</strong>.</p> <p><a href="http://blog.japila.pl/wp-content/uploads/2012/05/eclipse-clojure-import-existing-maven-project.png" rel="nofollow" target="_blank"></a></p> <p>After a while, when the compilation is done, from the context menu (under the right mouse button) of the project, select <strong>Run As > Clojure Application</strong>.</p> <p><a href="http://blog.japila.pl/wp-content/uploads/2012/05/eclipse-clojure-run-as-clojure-application.png" rel="nofollow" target="_blank"></a></p> <p>If no problems are encountered, the nREPL view is displayed and symbols are easily resolvable with the feature “Navigate to Definition”. Alternatively, you can use the key <strong>F3</strong>.</p> <p><a href="http://blog.japila.pl/wp-content/uploads/2012/05/eclipse-clojure-nrepl-view.png" rel="nofollow" target="_blank"></a></p> <p>Check it out and report how it works for you.</p> <div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=IYxDMnJdceM:jdrpCwY0hUo:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=IYxDMnJdceM:jdrpCwY0hUo:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>On Lisp in Clojure chapter 11 (section 11.1)</h1> <p>2012-05-25T19:13:00+00:00</p> <p>I am continuing to translate the examples from <a href="http://www.bookshelf.jp/texi/onlisp/onlisp_toc.html#SEC_Contents" rel="nofollow" target="_blank">On Lisp</a> by Paul Graham into Clojure. The examples and links to the rest of the series can be found on <a href="https://github.com/rickhall2000/OnLisp" rel="nofollow" target="_blank"> github</a>. </p> <p>Normally I would cover more than just 1 section in a post, but I thought material in this section could stand to be in its own discussion. In addition, the next section has so much in it that it will need its own post. </p> <p></p><h3><a href="http://www.bookshelf.jp/texi/onlisp/onlisp_12.html#SEC83" rel="nofollow" target="_blank">Section 11.1</a> Creating Context</h3>The call to let is included for completeness. I thought the definition of our-let was pretty neat. I think it shows pretty clearly what Graham means when he talks about using a macro to create a context. <p></p> <pre><br />(let [x 'b] (list x))<br /><br />(defmacro our-let [binds & body]<br /> `((fn [~@(take-nth 2 binds)]<br /> (do ~@body)) ~@(take-nth 2 (rest binds))))<br /><br />(macroexpand-1 '(our-let [x 1 y 2] (+ x y)))<br />;; ((clojure.core/fn [x y] (do (+ x y))) 1 2)<br /><br />(our-let [x 1 y 2] (+ x y))<br />;; 3<br /></pre><p>It seems like we get to see the when macro every chapter. It looked to me like the when-bind* was dropping all its variables, so clearly I don't understand it to translate it. In Clojure, gensym is done by appending # to any variable that you name in a macro. </p> <pre><br />(defmacro when-bind [[var expr] & body]<br /> `(let [~var ~expr]<br /> (when ~var<br /> ~@body)))<br /><br /></pre><p>Graham showed us a cond-let function that accepted a sequence of pairs containing a boolean expression followed by a let binding. In Graham's implementation he had two helper functions and one macro. I wrote it with one helper function that recursively walks through the boolean expressions until it finds one that is true. </p><pre><br />(defn condlet-bind [bindings]<br /> (loop [binds bindings]<br /> (cond (empty? binds) []<br /> (first binds) (first (rest binds))<br /> :default (recur (rest (rest binds))))))<br /><br />(defmacro condlet [clauses & body]<br /> `(let ~(condlet-bind clauses)<br /> ~@body))<br /><br /></pre><p>I want to point out the difference between this `condlet` function and Clojure.core's `if-let` function. condlet takes a list containing booleans and bindings, and will apply the first binding for which the boolean is true. if-let says if an expression is true, bind it to a symbol and execute one branch of code; if it is not true don't bind anything, and take a different branch. </p><p>In the following pseudo code, if some-expression returns a value other than false or nil, x gets bound to the result and do-something is called. If some-expression evaluates to false or nil, x does not get bound to anything and do-something-else gets called, just like a normal if. </p> <pre><br />#_(if-let [x (some-expression)]<br /> (do-something x)<br /> (do-something-else))<br /></pre><div class="blogger-post-footer"></div><div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=pvwDoujpc0w:F9q_mzQNLR4:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=pvwDoujpc0w:F9q_mzQNLR4:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>EuroClojure 2012 Day 1</h1> <p>2012-05-25T07:03:38+00:00</p> <p>So there were definitely two big themes in the talks on the first day of the conference.</p> <p>The first has been about how to use event-based systems to create flexible aggregate data models. All speakers seem to have settled on a reduce or foldLeft approach for creating the aggregate but there have been two models put forward already CQRS and a kind of Aggregate query bus but really it seems that responsibility for accepting event data and allow querying and access to aggregated views seem to be responsibilities in the same system.</p> <p>The other thing has been creating query systems using logical predicates. The were no less than three generic query systems put forward: core.logic for low-level flexible implementations that identify either data or results and two general query libraries: one from Datomic and the other from Cascalog.</p> <br /> <a href="http://feeds.wordpress.com/1.0/gocomments/rrees.wordpress.com/819/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/godelicious/rrees.wordpress.com/819/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/gofacebook/rrees.wordpress.com/819/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/gotwitter/rrees.wordpress.com/819/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/gostumble/rrees.wordpress.com/819/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/godigg/rrees.wordpress.com/819/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/goreddit/rrees.wordpress.com/819/" rel="nofollow"></a> <div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=np2ygdGPSFc:_-KVSMP4xGg:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=np2ygdGPSFc:_-KVSMP4xGg:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>understanding clojure concurrency, part 2</h1> <p>2012-05-25T05:00:00+00:00</p> <p><em>This is part 2 of a 2 part series I’m writing about Clojure concurrency. Check out the first post <a rel="nofollow">here</a></em></p> <h3 id="concurrency_primitives">concurrency primitives</h3> <p>Clojure provides a grab-bag of concurrency primitives and functions that give meaning and control to your multi-threaded code. Most programming languages leave these constructs up to the library writers - Clojure takes a different stance.</p> <h3 id="atoms">atoms</h3> <p>First, I’d like to talk about atoms. The concept of atomicity might not be new to you, but let’s recap just to solidify the idea. Atomicity implies that even in an environment with multiple actors (threads) working on the same piece of data, you can guarantee that updates to that data either happen entirely, or don’t happen at all. In practice, this is used when multiple threads are reading and writing to one data structure to share its contents. Here’s how you create an atom in Clojure:</p> <pre><code>user=> (atom 1) #<Atom@15c313da: 1></code></pre> <p>This will create an atom that houses the Java Integer 1 inside of it. To fetch the value of the atom, you use the deref function.</p> <pre><code>user=> (def a (atom 1)) #'user/a user=> a #<Atom@3f78e13f: 1> user=> (deref a) 1 user=></code></pre> <p>You can also deref an atom using the ’@’ shortcut:</p> <pre><code>user=> (def a (atom 1)) #'user/a user=> @a 1 user=></code></pre> <p>To change the value of a atom, you use the swap! function.</p> <pre><code>user=> a #<Atom@30394ffa: 1> user=> (swap! a inc) 2 user=></code></pre> <p>The swap! function takes the atom as its first argument, and a function to apply to the value in the atom. In this case, we applied the ‘inc’ function, which increments the integer by 1.</p> <p>Under the covers, the swap! function is doing a compare-and-set! operation, which means that if two threads are in a race to apply their function to the atom, the loser will retry their swap if the value has changed since they began the swap. Therefore, it’s very important that ‘swap!’ procedures be completely free of side-effects. No log writing, database updating or anything else - otherwise you’ll get unpredictable behavior in your I/O layers.</p> <p>Atoms also allow you to specify a :validator function. This function will be executed whenever the atom is attempting to change state:</p> <pre><code>user=> (def a (atom 1 :validator #(< % 10))) #'user/a user=> a #<Atom@476dc5c9: 1> user=> (swap! a (partial + 8)) 9 user=> a #<Atom@476dc5c9: 9> user=> (swap! a inc) java.lang.IllegalStateException: Invalid reference state (NO_SOURCE_FILE:0) user=> </code></pre> <p>In the example, we created an Integer that cannot be greater than 10. The first time we apply a swap function, the atom successfuly changes. When we try to increment the atom one more time up to 10, an IllegalStateException is thrown. This is really useful in cases where retrying a swap operation might put the atom in an illegal state, especially during thread races.</p> <p>What I love about atoms is how simple they are. You take an immutable persistent data type and you can make it atomic, without having to remake your entire processing pipeline or the underlying data structure. You get a tool that helps create data that is shared, synchronous, and independent in state. How do you know when it’s the right decision to use an atom? The general rule of thumb is that if you only have to manipulate one data item concurrently and synchronously, you should use an atom. A good example of this might be a counter that counts how many items have been sold in an online store - there might be multiple webserver trying to increment and decrement this number at once, but the count will always be guaranteed to be in a single state at any given moment in time.</p> <p>When you start needing to coordinate a group of data items that need to mutate together, you should start to think about Refs.</p> <h3 id="refs">refs</h3> <p>Because Clojure has immutable data structures, Refs provide a mechanism to track the same fact idea (identity) over a period of time. Let’s look at an example of this.</p> <p>Here are some facts I know to be true:</p> <ol> <li>On July 22, 2011 - Bob Anderson lived in Chicago.</li> <li>On September 14, 2011 - Bob Anderson lived in San Francisco</li> </ol> <p>In most programming languages, you might have a variable called ‘userLocation’ that you would update when Bob moves from Chicago to San Francisco. As far as your program is concerned, when you update the ‘userLocation’ variable, your program loses awareness that Bob ever lived in Chicago. Once you rewrite that variable, Bob’s previous location is lost forever. Now just because you updated the ‘userLocation’ to San Francisco doesn’t change the fact that at an earlier point in time, Bob lived in Chicago. What’s worse, is that any other thread that was holding on to the ‘userLocation’ variable would have its value change out from under it. This is where the nasty dragons live.</p> <p>What a Clojure Ref does is track a series of facts over time. So in the Clojure world, conceptually, a Ref looks like this:</p> <p>Question: “Where does Bob live at this point in time?”</p> <ol> <li>On July 22, 2011 - Bob Anderson lived in Chicago.</li> <li>On September 14, 2011 - Bob Anderson lived in San Francisco</li> </ol> <p>So in Clojure, you would have a Ref called user-location, and if Bob moves to a new location, you update the Ref to point to the newest fact (Bob living in San Francisco). Again, what a Ref does is tracks values over time. Before Bob moved, the Ref pointed to the fact that Bob lived in Chicago. When Bob moves, on September 14, 2011, the Ref points to the fact that Bob now lives in San Francisco. Anyone holding on to the previous value of ‘Chicago’ would still retain that value until it updated its state from the Ref.</p> <p>But that’s not the main use case for Refs.</p> <p>If atoms are for managing the fact changes of a single data structure, then Refs are for managing changes of multiple data structures together, atomically. Put simply, Refs give you in memory transactions using a software transactional memory system. I’m not going to get into the details of software transactional memory systems, but if you’re curious I’d recommend doing some reading on them. Let’s take our example with Bob and elaborate on it more.</p> <p>Bob’s company stores 2 facts about him, where he lives and how much his salary is. Both of these pieces of data always move together in a coordinated fashion to adjust for cost of living. When Bob moves from Chicago to San Francisco, his salary also needs to increase at the exact same time. Because these two facts are bound together, they either both change, or neither of them change. Let’s setup our two Refs and get started:</p> <div class="highlight"><pre><code class="clojure"> <span class="p">(</span><span class="k">def </span><span class="nv">location</span> <span class="p">(</span><span class="nb">ref </span><span class="s">"Chicago"</span><span class="p">))</span> <span class="p">(</span><span class="k">def </span><span class="nv">salary</span> <span class="p">(</span><span class="nb">ref </span><span class="mi">30000</span><span class="p">))</span> </code></pre> </div> <p>You access Ref values the same way you access atom values, using the deref function (or the @ prefix):</p> <pre><code>user=> @location "Chicago" user=> @salary 30000</code></pre> <p>We come to September 14, 2011 - time for Bob to move and get a salary bump at the exact same time. For this to happen as one atomic change, we need a transaction. Note that it is impossible for you to change the value of a Ref without a transaction. Clojure provides the ‘dosync’ macro that wraps an expression in a transaction for Ref changes.</p> <div class="highlight"><pre><code class="clojure"> <span class="p">(</span><span class="nf">dosync</span> <span class="p">(</span><span class="nb">ref-set </span><span class="nv">location</span> <span class="s">"San Francisco"</span><span class="p">)</span> <span class="p">(</span><span class="nb">alter </span><span class="nv">salary</span> <span class="p">(</span><span class="nb">partial </span><span class="nv">+</span> <span class="mi">15000</span><span class="p">)))</span> </code></pre> </div> <p>The first Ref we altered by simply changing its value to a completely new value. Again, Bob’s location used to be Chicago, but now it’s San Francisco. We achieved this change using the ‘ref-set’ function, which allows you to alter the value of a Ref outright. At the same time Bob moves to San Francisco, he gets a $15,000 pay increase. We represent this pay increase by applying the ‘alter’ operation to the salary Ref. Similar to the ‘swap!’ operation of the Atom, the alter command takes the Ref and a function to apply to the current Ref value - in our case we’re applying a plus operation to his salary. As far as other threads are concerned, both of these changes will happen at the same point in time. After we alter the values, we get the new expected values by derefing:</p> <pre><code>user=> @location "San Francisco" user=> @salary 45000</code></pre> <p>Refs give you the amazing power to coordinate several data structures, forcing their changes to occur together as one atomic group. Similar to atoms, if two threads attempt to change the value of a Ref at the same time, one of them will succeed and the other will fail. When the second one fails, it will be automatically retried. So, just like with Atoms, Ref transactions must be completely free of side effects.</p> <p>Keep in mind that the more data structures you group together into a transaction, the more transaction retries you will experience under heavy write load, and the more your performance will degrade. The less your data structures have to coordinate, the better. Think about it like trying to schedule a meeting with someone else. It’s not too hard to have the two of you find a common time to meet, but what happens when you have to schedule a meeting with ten busy people? It becomes much harder to get everyone in the same room at the same time. People often end up not showing up or the meeting gets moved or cancelled due to last minute scheduling conflicts. The same goes for manipulating many data structures in a single transaction. Remember this concept when doing coordinated Ref manipulation: the faster the transactions, and the less the participants, the better. Less coordination helps computers scale horizontally and go faster by doing more at once.</p> <h3 id="futures">futures</h3> <p>Futures are one of my favorite Clojure concurrency primitives. They offer a simple and flexible way to dispatch operations into another thread and then retrieve the results of that computation from the existing thread. Put more simply, they’re terrific at producing a request/response operation that occurs between two threads.</p> <p>To start off, let’s start playing around a bit:</p> <div class="highlight"><pre><code class="clojure"> <span class="p">(</span><span class="nf">future</span> <span class="p">(</span><span class="nf">Thread/sleep</span> <span class="mi">1000</span><span class="p">)</span> <span class="p">(</span><span class="nb">prn </span><span class="s">"Hello futures!"</span><span class="p">))</span> </code></pre> </div> <p>When you execute this in your REPL, you’ll notice that it returns immediately, and 1 second later a print message sent to standard out. This use of futures doesn’t give us much over newing up a Thread and telling it to print to the screen. Futures give us the ability deref and retrieve the value the Thread returns in the exact same way we deref Atoms and Refs. Let’s do that now using a simple factorial function:</p> <div class="highlight"><pre><code class="clojure"> <span class="p">(</span><span class="k">defn </span><span class="nv">factorial</span> <span class="p">[</span><span class="nv">n</span><span class="p">]</span> <span class="p">(</span><span class="nb">apply </span><span class="nv">*</span> <span class="p">(</span><span class="nb">map </span><span class="nv">bigint</span> <span class="p">(</span><span class="nb">range </span><span class="mi">1</span> <span class="p">(</span><span class="nb">inc </span><span class="nv">n</span><span class="p">)))))</span> </code></pre> </div> <p>If we want to find the factorial of a very large number, we can perform this computation in another thread and then retrieve the computed value using our handy friend deref:</p> <div class="highlight"><pre><code class="clojure"> <span class="p">(</span><span class="k">def </span><span class="nv">result</span> <span class="p">(</span><span class="nf">future</span> <span class="p">(</span><span class="nf">factorial</span> <span class="mi">10000</span><span class="p">)))</span> <span class="o">...</span> <span class="nv">do</span> <span class="nv">some</span> <span class="nv">other</span> <span class="nv">things</span> <span class="nv">here</span> <span class="o">...</span> <span class="p">(</span><span class="nb">deref </span><span class="nv">result</span><span class="p">)</span> </code></pre> </div> <p>Following the same pattern, deref will return the result immediately if the future has already completed, otherwise it will block until the future is done. In this case, we dispatched a really expensive action to another thread, so our main thread could continue execution. Then, when our main thread is ready to consume the result of the future, it simply derefs it like we’ve seen before. I like to think of this like a request/response pattern that spans multiple threads instead of two servers. You can offload the heavy lifting to something else, and keep on doing what you’re doing.</p> <p>Now let’s step it up another notch and do something non-trivial. A user on my website uploads a photo album, and I want to back all of the images up to Amazon S3. I could iterate through each photo and upload them one at a time, but that would be slow and would waste a lot of CPU cycles simply waiting for a response from Amazon. Why don’t we instead use a collection of futures to fan out the images simultaneously? Let me show you how this is done.</p> <p>First, let’s assume the user has just submitted all the files to the server, and they’re sitting in memory as a collection of java BufferedImages. To simulate this, I’m just going to read the same image 10 times:</p> <div class="highlight"><pre><code class="clojure"> <span class="p">(</span><span class="nb">import </span><span class="p">[</span><span class="nv">javax</span><span class="o">.</span><span class="nv">imageio</span> <span class="nv">ImageIO</span><span class="p">])</span> <span class="p">(</span><span class="k">def </span><span class="nv">images</span> <span class="p">(</span><span class="nb">take </span><span class="mi">10</span> <span class="p">(</span><span class="nf">repeatedly</span> <span class="o">#</span><span class="p">(</span><span class="nv">ImageIO/read</span> <span class="p">(</span><span class="nf">clojure</span><span class="o">.</span><span class="nv">java</span><span class="o">.</span><span class="nv">io/input-stream</span> <span class="s">"/Users/blake/Pictures/blake_signature.jpg"</span><span class="p">)))))</span> </code></pre> </div> <p>Utilizing the ‘repeatedly’ function to generate an infinite sequence of BufferedImages, we only realized 10 of them using the ‘take’ function. We have a collection of BufferedImages, now let’s upload all 10 of them concurrently to S3. To do this, I’m going to use the ‘clj-aws-s3’ library. First, let’s write our function that will upload the image to S3 itself:</p> <div class="highlight"><pre><code class="clojure"> <span class="p">(</span><span class="nf">require</span> <span class="p">[</span><span class="nv">aws</span><span class="o">.</span><span class="nv">sdk</span><span class="o">.</span><span class="nv">s3</span> <span class="nv">:as</span> <span class="nv">s3</span><span class="p">])</span> <span class="p">(</span><span class="k">def </span><span class="nv">credentials</span> <span class="p">{</span><span class="nv">:access-key</span> <span class="s">"my s3 access key"</span> <span class="nv">:secret-key</span> <span class="s">"super secret key"</span><span class="p">})</span> <span class="p">(</span><span class="k">def </span><span class="nv">bucket-name</span> <span class="s">"user-images"</span><span class="p">)</span> <span class="p">(</span><span class="k">defn </span><span class="nv">save-image</span> <span class="p">[</span><span class="nv">image</span> <span class="nv">filename</span><span class="p">]</span> <span class="p">(</span><span class="nb">with-open </span><span class="p">[</span><span class="nv">os</span> <span class="p">(</span><span class="nf">ByteArrayOutputStream</span><span class="o">.</span><span class="p">)]</span> <span class="p">(</span><span class="nf">ImageIO/write</span> <span class="nv">image</span> <span class="s">"jpg"</span> <span class="nv">os</span><span class="p">)</span> <span class="p">(</span><span class="k">let </span><span class="p">[</span><span class="nv">request</span> <span class="p">(</span><span class="nf">s3/put-object</span> <span class="nv">credentials</span> <span class="nv">bucket-name</span> <span class="nv">filename</span> <span class="p">(</span><span class="nf">clojure</span><span class="o">.</span><span class="nv">java</span><span class="o">.</span><span class="nv">io/input-stream</span> <span class="p">(</span><span class="o">.</span><span class="nv">toByteArray</span> <span class="nv">os</span><span class="p">)))]</span> <span class="p">{</span><span class="nv">:finished</span> <span class="nv">true</span> <span class="nv">:request</span> <span class="nv">request</span><span class="p">})))</span> </code></pre> </div> <p>That looks like a lot, but it’s not so bad. First we set up some of our boilerplate code. We import the s3 library and then define our S3 credentials using a hash map and set our S3 bucket name. Our ‘upload-image’ function takes a BufferedImage as input, and a desired filename for the image in our S3 bucket. From there, we open a new ByteArrayOutputStream. This is where we’re going to write the raw bytes from our image to in preparation for uploading them. After that, we build a request and invoke the ‘s3/put-object’ with our credentials, filename and an InputStream from our ByteArrayOutputStream. We basically wrote out the bytes into memory and then read them out again to upload to S3. That returns a s3 request object which we inspect to write out to our hash map along with an easy to access :finished key which all gets returned from the function. Conceptually, all this function is really doing is reading the raw bytes out of the BufferedImage and then shuttling them off to S3.</p> <p>Now, let’s write one more function that’s takes our entire BufferedImage collection as input and utilizes futures to fan multiple threads out to S3 all simultaneously:</p> <div class="highlight"><pre><code class="clojure"> <span class="p">(</span><span class="k">defn </span><span class="nv">upload-images</span> <span class="p">[</span><span class="nv">images</span><span class="p">]</span> <span class="p">(</span><span class="nf">doall</span> <span class="p">(</span><span class="nf">map-indexed</span> <span class="p">(</span><span class="k">fn </span><span class="p">[</span><span class="nv">image</span> <span class="nv">i</span><span class="p">]</span> <span class="p">(</span><span class="nf">future</span> <span class="p">(</span><span class="nf">upload-image</span> <span class="nv">image</span> <span class="p">(</span><span class="nf">format</span> <span class="s">"myimage-%s.jpg"</span> <span class="nv">i</span><span class="p">))))</span> <span class="nv">images</span><span class="p">)))</span> </code></pre> </div> <p>We’re mapping over our collection of images, and for each image we’re generating a future thats body content will upload the image to S3. When we invoke this function, we’ll get back a collection of futures, each one representing one image that’ll get uploaded by one of the threads in the thread pool. Keep in mind that once the thread pool is exhausted, other futures will have to wait for a thread to become available again.</p> <p>Let’s try out our parallel uploading:</p> <div class="highlight"><pre><code class="clojure"> <span class="p">(</span><span class="k">def </span><span class="nv">f</span> <span class="p">(</span><span class="nf">upload-images</span> <span class="nv">images</span><span class="p">))</span> <span class="p">(</span><span class="nb">map </span><span class="nv">deref</span> <span class="nv">f</span><span class="p">)</span> </code></pre> </div> <p>When every single image upload completes, you’ll get back a collection of hashes like the one we defined in ‘save-image’.</p> <p>Like I mentioned earlier, futures are one of my favorite concurrency primitives, because they allow you to dish out heavy or long running tasks to a thread pool with ease, letting your main execution path continue on its marry way, and not get bogged down by long running requests.</p> <h3 id="agents">agents</h3> <p>Let’s say you have a problem that almost warrants the use of an Atom, but you need your functionality to be <em>asynchronous</em> instead of <em>synchronous</em>. On top of that, you know that it’s a bad idea to use Atoms when your functions have side-effects, because they might get invoked several times when threads are competing, but your functions are going to do some I/O. What can you do? You should consider using Agents.</p> <p><em>Note: the following example was borrowed from <a href="http://lethain.com/a-couple-of-clojure-agent-examples/" rel="nofollow" target="_blank">Will Larson</a></em></p> <p>One great use case for Agents is for shared logging. We’re writing our program, and we have several threads that need to log to the same shared BufferedWriter file. We know that BufferedWriter is not a thread safe data structure, and ignoring this fact will lead to strange interleaving in our log files due to thread contention. We also know that our logging use case is something that can happen asynchronously from our main app logic - logging really shouldn’t be stopping the main flow of your program execution. Agents will help us solve this problem quite easily.</p> <p>First, we wrap the BuffedWriter in an agent, similar to how we wrap Atoms and Refs.</p> <div class="highlight"><pre><code class="clojure"> <span class="p">(</span><span class="nb">import </span><span class="p">[</span><span class="nv">java</span><span class="o">.</span><span class="nv">io</span> <span class="nv">BufferedWriter</span> <span class="nv">FileWriter</span><span class="p">])</span> <span class="p">(</span><span class="k">def </span><span class="nv">logfile</span> <span class="p">(</span><span class="nb">agent </span><span class="p">(</span><span class="nf">BufferedWriter</span><span class="o">.</span> <span class="p">(</span><span class="nf">FileWriter</span><span class="o">.</span> <span class="s">"shared-logfile.log"</span><span class="p">))))</span> </code></pre> </div> <p>Now let’s go ahead and write our log function that’s going to handle writing out to the BufferedWriter.</p> <div class="highlight"><pre><code class="clojure"> <span class="p">(</span><span class="k">defn </span><span class="nv">write-out</span> <span class="p">[</span><span class="nv">out</span> <span class="nv">msg</span><span class="p">]</span> <span class="p">(</span><span class="o">.</span><span class="nv">write</span> <span class="nv">out</span> <span class="nv">msg</span><span class="p">)</span> <span class="nv">out</span><span class="p">)</span> </code></pre> </div> <p>This function writes to the BufferedWriter, and then returns the instance of the BufferedWriter. We’ll see why it’s important to return the BufferedWriter instance in a moment.</p> <p>Now, we need a way to dispatch our write-out function to the agent. To do this, we use the built-in ‘send’ function.</p> <div class="highlight"><pre><code class="clojure"> <span class="p">(</span><span class="k">defn </span><span class="nv">log</span> <span class="p">[</span><span class="nv">logger</span> <span class="nv">msg</span><span class="p">]</span> <span class="p">(</span><span class="nb">send </span><span class="nv">logger</span> <span class="nv">write-out</span> <span class="nv">msg</span><span class="p">))</span> <span class="p">(</span><span class="k">defn </span><span class="nv">close</span> <span class="p">[</span><span class="nv">logger</span><span class="p">]</span> <span class="p">(</span><span class="nb">send </span><span class="nv">logger</span> <span class="o">#</span><span class="p">(</span><span class="o">.</span><span class="nv">close</span> <span class="nv">%</span><span class="p">)))</span> </code></pre> </div> <p>The first parameter to ‘send’ is the agent itself, followed by the function to apply to the agent, and any additional arguments to pass into the function. In our case, we’re applying the write-out function to the logger agent and passing the message along to the write-out function. Then we can send log events to the logger using the ‘log’ function:</p> <div class="highlight"><pre><code class="clojure"> <span class="p">(</span><span class="nf">log</span> <span class="nv">logfile</span> <span class="s">"My awesome message"</span><span class="p">)</span> <span class="p">(</span><span class="nf">log</span> <span class="nv">logfile</span> <span class="s">"My other awesome message"</span><span class="p">)</span> <span class="p">(</span><span class="nf">close</span> <span class="nv">logfile</span><span class="p">)</span> </code></pre> </div> <p>And both of those log lines would be present in our log file. This is all fine and well, but it doesn’t really demonstrate the reason we used agents in the first place. We chose agents because we wanted to be able to have multiple threads writing to the same log file without any interleave or contention issues. Let’s throw a bunch of threads at our logger, and have them all write out to the log file:</p> <div class="highlight"><pre><code class="clojure"> <span class="p">(</span><span class="nb">dotimes </span><span class="p">[</span><span class="nv">i</span> <span class="mi">1000</span><span class="p">]</span> <span class="p">(</span><span class="nf">future</span> <span class="p">(</span><span class="nf">log</span> <span class="nv">logfile</span> <span class="p">(</span><span class="nf">format</span> <span class="s">"Message number %s\n"</span> <span class="nv">i</span><span class="p">))))</span> <span class="p">(</span><span class="nf">close</span> <span class="nv">logfile</span><span class="p">)</span> </code></pre> </div> <p>This will utilize a thread pool to write all those log events to the file. When I open up my logfile to see the results, I get something tha looks like this:</p> <pre><code>Message number 1 Message number 3 Message number 5 Message number 9 Message number 11 Message number 22 Message number 23 Message number 24 Message number 25 ...</code></pre> <p>You’ll notice that the log numbers are not in order - because multiple threads were trying to write to the file at the same time, so ordering is not guaranteed or expected. The good news is, none of our log lines are interleaved. This is due to our functions being applied to the agent in a serial fashion. Think of agents like a queue for the functions you want to apply to some piece of state. Even though multiple threads are trying to apply their function to the agent at the same time, all the function calls get ordered and applied one after the other.</p> <p>There are two ways you can dispatch a function to an agent. You can use the ‘send’ function like we did in the example, or you can use the ‘send-off’ function. On the surface, these two functions appear to do the same thing, with a subtle difference. Under the covers, ‘send’ uses a thread pool that has a fixed size, depending on the number of cores your CPU has. This means that if one of the threads from the thread pool blocks for a long period of time, you risk starving your agent from available threads. If all the threads in the thread pool block for a long period of time, you’ll get a backup of ‘sends’.</p> <p>On the other hand, using ‘send-off’ will utilize a separate thread pool that is capable of growing in size. This means that if your threads block for any lengthy period of time, more threads can be created to accomodate the increasing demands (up to a certain point).</p> <p>What does this mean for you as the programmer? The general rule of thumb is if you’re making long I/O calls, like going out to the network for something, use ‘send-off’. If your operations are generally CPU bound, or risk no chance of blocking for a long time, use ‘send’.</p> <h3 id="promises">promises</h3> <p>In a basic sense, a promise is a contract between one thread and another to deliver a calculation at some point in the future. Put another way, a promise is a mechanism to safetly deliver data between two threads. Let’s walk through a circumstance where using a promise might ease the ability to share data in between concurrent processes.</p> <p>Imagine you’re planning a party. The restaurant party manager calls you three weeks before the event to get the guest count. You don’t yet know how many people are going to come to your party, but you expect you’ll have the final head count soon. You tell the party manager that you’re still working on getting final head count and that you’ll call him and let him know as soon as you’ve got the number nailed down. You work on getting the last RSVPs gathered, and three days later you call back the restaurant owner and give him the final count.</p> <p>In this example, you don’t know what the exact guest count is, but you know it’s a number you’re going to have to give the party manager in the future - so you make him a <em>promise</em> that you’ll tell him the final count as soon as you know it. Then you go about calling your invited guests to sum the total count. Once you know number, you <em>deliver</em> on that promise by calling the manager back and telling him what it is.</p> <p>This interaction represents how you might use Clojure promises. The typical pattern goes like this:</p> <ul> <li>A thread generates a promise by invoking the ‘promise’ function with no arguments.</li> </ul> <div class="highlight"><pre><code class="clojure"> <span class="p">(</span><span class="k">def </span><span class="nv">guest-count</span> <span class="p">(</span><span class="nf">promise</span><span class="p">))</span> </code></pre> </div> <ul> <li>That thread passes the promise along to another thread. This states the intetion “I am going to deliver the guest count to you at some point in the future when I know it”. That other thread is free to do other things while waiting on the value contained in the promise, and check to see if the other thread delivered the value periodically.</li> </ul> <div class="highlight"><pre><code class="clojure"> <span class="p">(</span><span class="nf">future</span> <span class="p">(</span><span class="nf">manager-duties</span> <span class="nv">guest-count</span><span class="p">))</span> </code></pre> </div> <p>In this case, we use a future to perform all the manager duties in another thread. The manager duties might be described like this:</p> <div class="highlight"><pre><code class="clojure"> <span class="p">(</span><span class="k">defn </span><span class="nv">talk-to-guests</span> <span class="p">[]</span> <span class="p">(</span><span class="nb">prn </span><span class="s">"Talking to guests"</span><span class="p">))</span> <span class="p">(</span><span class="k">defn </span><span class="nv">train-wait-staff</span> <span class="p">[]</span> <span class="p">(</span><span class="nb">prn </span><span class="s">"Training wait staff"</span><span class="p">))</span> <span class="p">(</span><span class="k">defn </span><span class="nv">check-party-guest-count</span> <span class="p">[</span><span class="nv">p</span><span class="p">]</span> <span class="p">(</span><span class="k">if </span><span class="p">(</span><span class="nf">realized?</span> <span class="nv">p</span><span class="p">)</span> <span class="p">(</span><span class="nb">deref </span><span class="nv">p</span><span class="p">)</span> <span class="p">(</span><span class="nb">prn </span><span class="s">"Don't know the guest count yet, call later"</span><span class="p">)))</span> <span class="p">(</span><span class="k">defn </span><span class="nv">manager-duties</span> <span class="p">[</span><span class="nv">cnt</span><span class="p">]</span> <span class="p">(</span><span class="nf">talk-to-guests</span><span class="p">)</span> <span class="p">(</span><span class="nf">train-wait-staff</span><span class="p">)</span> <span class="p">(</span><span class="nb">if-let </span><span class="p">[</span><span class="nv">count</span> <span class="p">(</span><span class="nf">check-party-guest-count</span> <span class="nv">cnt</span><span class="p">)]</span> <span class="p">(</span><span class="nb">prn </span><span class="p">(</span><span class="nf">format</span> <span class="s">"Total guest count is %s"</span> <span class="nv">count</span><span class="p">))</span> <span class="p">(</span><span class="nf">do</span> <span class="p">(</span><span class="nf">Thread/sleep</span> <span class="mi">1000</span><span class="p">)</span> <span class="p">(</span><span class="nf">manager-duties</span> <span class="nv">cnt</span><span class="p">))))</span> </code></pre> </div> <p>We set up a few tasks for the party manager to perform, and he performs them continually. Notice the use of the ‘realized?’ function in the ‘check-party-guest-count’ function. This function can be used on promises to check if the promise has been delived yet. You may need to do this in some circumstances if you don’t want to invoke ‘deref’ and block until the promise is delivered.</p> <ul> <li>The guest count is delivered from the main thread, thus completing the promise. The manager stops performing his tasks.</li> </ul> <div class="highlight"><pre><code class="clojure"> <span class="p">(</span><span class="nf">deliver</span> <span class="nv">guest-count</span> <span class="mi">50</span><span class="p">)</span> </code></pre> </div> <p>When I first encountered promises, I was confused about how they differ from futures. When do I use one and when would I use the other? Let me explain the difference. With futures, your main thread of execution is delegating work to another thread. When the value of the future comes back, the main thread gets to harvest this value and benefit from it. With promises, this relationship is usually inverted. The main thread of execution generates a promise, and passes it off to another thread. The main thread of execution does the hard work to generate the value that will be delivered, and delivers it to the second thread. The second thread gets to benefit from the hard work of the main thread.</p> <p>One handy rule of thumb for determining whether to use a future or a promise is:</p> <ol> <li>I want another thread to do my work for me and tell me the result: use a future.</li> <li>I want to do the work and tell the other thread when I’m done: use a promise.</li> </ol> <h3 id="the_world_ahead">the world ahead</h3> <p>I hope you’ll come away from this feeling more empowered to write concurrent Clojure programs. Part of the challenge of learning this stuff is figuring out the new patterns and different ways of thinking that are required to write concurrent code. Concurrent and parallel programming is a very big topic, and this series of posts serves as a way to get excited about the potential of multi-threaded programming with Clojure. In a lot of ways, our computer systems have run out of affordable vertical scaling runway - the future holds the growing need to make our computer systems grow horizontally, and thus places more demands on the programmer to write concurrent code. I believe that mastering this stuff can open up doors to all kinds of problems you didn’t even think solvable. Jump in, and have fun!</p><div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=fNYsq8bueVA:bz0Ziyb9n_8:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=fNYsq8bueVA:bz0Ziyb9n_8:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>Clojure: expectations, colorized</h1> <p>2012-05-24T13:00:05+00:00</p> The current version of expectations (1.4.3) prints colorized results by default on non-windows boxes. <br /><br />The following screenshot is an example of the output when no tests are failing: <br /><br /><div class="separator" style="clear: both;"><a href="http://3.bp.blogspot.com/-zlr9XXR-uLQ/T6_gdCp5R2I/AAAAAAAAAFw/yHY4UzHsl9I/s1600/Screen%2Bshot%2B2012-05-13%2Bat%2B12.24.38%2BPM.png"></a></div><br />And, the following screenshot is an example of the output when there are failures or errors: <br /><br /><div class="separator" style="clear: both;"><a href="http://1.bp.blogspot.com/-nJLOoI3ovps/T6_hHaL6FmI/AAAAAAAAAF8/kTH_w4sVvpQ/s1600/Screen%2Bshot%2B2012-05-13%2Bat%2B12.27.03%2BPM.png"></a></div><br />Colorized output is one of those small things that is easy to de-prioritize, but once it's done you can't figure out why you didn't do it earlier. The code to colorize your results is very simple, and there's even a lib, <a href="https://github.com/ibdknox/colorize">colorize</a>, if you prefer to simply include a dependency instead. <br /><br />Of course, if you prefer to stick with non-colorized results that's possible as well - simply set the environment variable EXPECTATIONS_COLORIZE to 'false'.<div class="blogger-post-footer"><br /><a href="http://www.jayfields.com">© Jay Fields - www.jayfields.com</a></div><div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=joS-o4o84ug:6bbzSf8hAns:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=joS-o4o84ug:6bbzSf8hAns:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>The root of polymorphism: The Anti-If Campaign</h1> <p>2012-05-24T12:09:53+00:00</p> Ever heard about the <a href="http://www.antiifcampaign.com/" target="_blank">Anti-If Campaign</a>? The less <span style="font-family: 'Courier New', Courier, monospace;">if</span>-statements there are in your code, the better -- argues Francesco Cirillo, the initiator of the Anti-If Campaign. There is a lot of truth behind his campaign. Too much <span style="font-family: 'Courier New', Courier, monospace;">if</span>-statements in your code are evil, that's for sure. They'll make your code static, hard to maintain and no fun to read. It goes without saying that related concepts like switch-statements, conditionals and the like are subsumed under "<span style="font-family: 'Courier New', Courier, monospace;">if</span>". They are just syntactic sugar for a certain arrangement of <span style="font-family: 'Courier New', Courier, monospace;">if</span>-statements.<br /><br />I asked myself: What if we abandon <span style="font-family: 'Courier New', Courier, monospace;">if</span>-statements completely? What about being absolutely strict about the use of <span style="font-family: 'Courier New', Courier, monospace;">if</span> and related concepts: No <span style="font-family: 'Courier New', Courier, monospace;">if</span>s in your code anywhere anyplace. You are not allowed to use <span style="font-family: 'Courier New', Courier, monospace;">if</span> at all. It is like not having such a construct in your programming language.<br /><br />Is it possible to write code without <span style="font-family: 'Courier New', Courier, monospace;">if</span>s? Yes, it is, as I'll show in this post. You'll end up with polymorphic functions instead -- and this is really cool stuff. Polymorphic functions are a result of having no <span style="font-family: 'Courier New', Courier, monospace;">if</span>s at your fingertips.<br /><br />So let us proclaim the <span style="font-family: inherit;"><i>No-If Campaign</i> for the sake of being extreme</span> -- and see where it leads us to. In the following, I'll use Clojure for demonstration purposes. <a href="http://clojure.org/" target="_blank">Clojure</a> is a functional programming language and belongs to the family of Lisp languages. Don't worry if you don't know Clojure. The programs are simple to grasp and should let you follow the line of argumentation.<br /><br /><h3> The Magic with Maps</h3><div>A map, sometimes also called dictionary, associative array or hash map, is a data structure that stores pairs of key values and target values. A key value is uniquely associated with a target value. In Clojure, maps are written with curly braces. The example interaction at the console (called REPL in Clojure speak) associates so-called keywords with numbers; the ordering of the pairs is irrelevant.</div><div><br /></div><div><div><span style="font-family: 'Courier New', Courier, monospace;">user=> (def day {:mon 1 :tue 2 :wed 3 :thu 4 :fri 5})</span></div><div><span style="font-family: 'Courier New', Courier, monospace;">#'user/day</span></div></div><div><br /></div><div>It is a specialty of Lisp-like languages, that programs are written with parentheses. It's something one quickly gets used to. The above code defines <span style="font-family: 'Courier New', Courier, monospace;">day </span>to be bound to a map with the given elements.</div><div><br /></div><div>To query a map, the map and a key value must be given.</div><div><br /></div><div><div><span style="font-family: 'Courier New', Courier, monospace;">user=> (day :thu)</span></div><div><span style="font-family: 'Courier New', Courier, monospace;">4</span></div><div><span style="font-family: 'Courier New', Courier, monospace;">user=> (day :sat)</span></div><div><span style="font-family: 'Courier New', Courier, monospace;">nil</span></div></div><div><br /></div><div>If there is no target value associated with a key value, <span style="font-family: 'Courier New', Courier, monospace;">nil</span> is returned. We can provide a default value as an extra argument to be returned instead.</div><div><br /></div><div><div><span style="font-family: 'Courier New', Courier, monospace;">user=> (day :thu 0)</span></div><div><span style="font-family: 'Courier New', Courier, monospace;">4</span></div><div><span style="font-family: 'Courier New', Courier, monospace;">user=> (day :sat 0)</span></div><div><span style="font-family: 'Courier New', Courier, monospace;">0</span></div></div><div><br /></div><div>The notion of equality is built into maps. Otherwise we couldn't query a map. That means: We can re-implement "equality" with the help of a map.</div><div><br /></div><div><div><span style="font-family: 'Courier New', Courier, monospace;">user=> (defn equal? [x y] ({y true} x false))</span></div><div><span style="font-family: 'Courier New', Courier, monospace;">#'user/equal?</span></div></div><div><br /></div><div>The code defines a function called <span style="font-family: 'Courier New', Courier, monospace;">equal?</span> that expects two arguments, namely <span style="font-family: 'Courier New', Courier, monospace;">x</span> and <span style="font-family: 'Courier New', Courier, monospace;">y</span>. The body of the functions says: if <span style="font-family: 'Courier New', Courier, monospace;">x</span> is not a key value in map <span style="font-family: 'Courier New', Courier, monospace;">{y true}</span> return <span style="font-family: 'Courier New', Courier, monospace;">false</span>; otherwise, if <span style="font-family: 'Courier New', Courier, monospace;">x</span> equals <span style="font-family: 'Courier New', Courier, monospace;">y</span> return <span style="font-family: 'Courier New', Courier, monospace;">true</span>.</div><div><br /></div><div>Let this use of a map sink in for a moment. Once you get the overall idea, it is easy to see how we can re-implement <span style="font-family: 'Courier New', Courier, monospace;">if</span>.</div><div><br /></div><div>How does <span style="font-family: 'Courier New', Courier, monospace;">if </span>work in Clojure? In Clojure, <span style="font-family: 'Courier New', Courier, monospace;">if</span> is a so-called special form. It expects at least two arguments, a third argument is optional. The evaluation of an <span style="font-family: 'Courier New', Courier, monospace;">if</span> is as follows: If the evaluation of the first arguments results in <span style="font-family: 'Courier New', Courier, monospace;">false </span>or <span style="font-family: 'Courier New', Courier, monospace;">nil</span>, the third argument is evaluated and its result returned; if the third argument is missing, <span style="font-family: 'Courier New', Courier, monospace;">nil </span>is returned. If the evaluation of the first argument is neither <span style="font-family: 'Courier New', Courier, monospace;">false</span> nor <span style="font-family: 'Courier New', Courier, monospace;">nil</span>, the second argument is evaluated and its result returned. It sounds more complicated than it actually is. Let us take an example</div><div><br /></div><div><div><span style="font-family: 'Courier New', Courier, monospace;">user=> (if (== 2 3) (+ 2 3) (- 2 3))</span></div><div><span style="font-family: 'Courier New', Courier, monospace;">-1</span></div></div><div><br /></div><div>Since the evaluation of <span style="font-family: 'Courier New', Courier, monospace;">(== 2 3)</span> leads to <span style="font-family: 'Courier New', Courier, monospace;">false</span>, the third argument to <span style="font-family: 'Courier New', Courier, monospace;">if</span> is evaluated, which results in <span style="font-family: 'Courier New', Courier, monospace;">-1</span>. Easy, isn't it?!</div><div><br /></div><div>We could emulate this behavior with a map in the following way:</div><div><br /></div><div><div><span style="font-family: 'Courier New', Courier, monospace;">user=> (eval ({false '(- 2 3) nil '(- 2 3)} (== 2 3) '(+ 2 3)))</span></div><div><span style="font-family: 'Courier New', Courier, monospace;">-1</span></div></div><div><br /></div><div>In the map, there are key values for <span style="font-family: 'Courier New', Courier, monospace;">false</span> and <span style="font-family: 'Courier New', Courier, monospace;">nil</span>, which are both associated to the same expression. They are quoted (that's what the apostrophe is for) to suppress premature evaluation. The default expression <span style="font-family: 'Courier New', Courier, monospace;">'(+ 2 3)</span> is quoted for the very same reason. Depending on the evaluation of the test-expression, here <span style="font-family: 'Courier New', Courier, monospace;">(== 2 3)</span>, either the default expression or the target value is taken. The resulting expression is evaluated by <span style="font-family: 'Courier New', Courier, monospace;">eval</span>.</div><div><br /></div><div>We can capture this use of a map as a coding pattern with the help of a macro. Let us call the macro <span style="font-family: 'Courier New', Courier, monospace;">IF</span> -- for obvious reasons.</div><div><br /></div><div><div><span style="font-family: 'Courier New', Courier, monospace;">(defmacro IF</span></div><div><span style="font-family: 'Courier New', Courier, monospace;"> ([test then]</span></div><div><span style="font-family: 'Courier New', Courier, monospace;"> `(IF ~test ~then nil))</span></div><div><span style="font-family: 'Courier New', Courier, monospace;"> ([test then else]</span></div><div><span style="font-family: 'Courier New', Courier, monospace;"> `(eval ({false '~else, nil '~else} ~test '~then))))</span></div></div><div><br /></div><div>Don't worry when you don't get all the details of macros and the special characters used inside. The point is that</div><div><ol><li>this macros behaves exactly like an <span style="font-family: 'Courier New', Courier, monospace;">if</span> without using an <span style="font-family: 'Courier New', Courier, monospace;">if</span> for its implementation. It is a proof-of-concept: We can live without <span style="font-family: 'Courier New', Courier, monospace;">if</span> -- because we can re-built it from maps.</li><li>this macro reads like a perfect specification of an <span style="font-family: 'Courier New', Courier, monospace;">if</span>, which is a very interesting aspect of our approach.</li></ol></div><div><div><span style="font-family: 'Courier New', Courier, monospace;">user=> (IF (== 2 3) (+ 2 3) (- 2 3))</span></div><div><span style="font-family: 'Courier New', Courier, monospace;">-1</span></div></div><div><br /></div><div>(Note to experts: Because of <span style="font-family: 'Courier New', Courier, monospace;">eval</span>, the macro does not respect lexical scope. Nothing to worry about in a proof-of-concept demonstration.)</div><div><br /></div><div>To conclude: Yes, we don't need <span style="font-family: 'Courier New', Courier, monospace;">if</span> as long as we have maps natively provided in our programming language. We can re-implement <span style="font-family: 'Courier New', Courier, monospace;">if</span>.</div><div><br /></div><div>This sounds ridiculous: We proclaim the No-If Campaign just in order to re-introduce <span style="font-family: 'Courier New', Courier, monospace;">if</span>-statements? You are right, we need <span style="font-family: 'Courier New', Courier, monospace;">if</span>-statements one way or the other. We can't seriously get rid of them. In programming, the concept of choice is essential and needs to be used. <span style="font-family: 'Courier New', Courier, monospace;">if</span>-statements are just the most primitive <i>binary choice construct</i> you can think of -- and they have their meaning and use.</div><div><br /></div><div>But there is another lesson to be learnt from re-implementing <span style="font-family: 'Courier New', Courier, monospace;">if</span> with a map. With maps, we have a <i>multiple choice construct</i>, which can be instrumented for implementing polymorphic functions.</div><div><br /></div><h3> Polymorphism</h3>Instead of choosing either something based on <span style="font-family: 'Courier New', Courier, monospace;">false</span>/<span style="font-family: 'Courier New', Courier, monospace;">nil</span> or choosing something else otherwise (<i>binary choice</i>), we generalize the idea of choice with maps. Based on any kind and any number of key values a map returns an associated target value (<i>multiple choice</i>). To get rid of the use of <span style="font-family: 'Courier New', Courier, monospace;">eval</span> (see our <span style="font-family: 'Courier New', Courier, monospace;">IF</span> macro), we demand that any value associated with a key value has to be a function.<br /><br />Assumed we would like to calculate the area of a given geometric shape. The formulas are dependent on the type of shape. The area of a circle is computed in another way than the area of a rectangle. This knowledge can be encoded with a map.<br /><br /><br /><span style="font-family: 'Courier New', Courier, monospace;">(def shape2func</span><br /><span style="font-family: 'Courier New', Courier, monospace;"> {:circle (fn [r] (* r r Math/PI))</span><br /><span style="font-family: 'Courier New', Courier, monospace;"> :rectangle (fn [a b] (* a b))</span><br /><span style="font-family: 'Courier New', Courier, monospace;"> :triangle (fn [a h] (* a h 0.5))})</span><br /><br />Now, we define a function <span style="font-family: 'Courier New', Courier, monospace;">area </span>which expects at least one argument. This very argument acts as a sort of identifier for choosing the right function from map <span style="font-family: 'Courier New', Courier, monospace;">shape2func</span>. The function is applied on any further arguments supplied with function <span style="font-family: 'Courier New', Courier, monospace;">area</span>.<br /><br /><br /><br /><span style="font-family: 'Courier New', Courier, monospace;">(defn area [shape & args]</span><br /><span style="font-family: 'Courier New', Courier, monospace;"> (apply (shape2func shape) args))</span><br /><br /><br /><div>Function <span style="font-family: 'Courier New', Courier, monospace;">area</span> has become a polymorphic function! Based on the value of some argument -- here the very first argument identifying the kind or type of shape one refers to -- a proper implementation is chosen and called.</div><div><br /></div><div><div><span style="font-family: 'Courier New', Courier, monospace;">user=> (area :circle 2)</span></div><div><span style="font-family: 'Courier New', Courier, monospace;">12.566370614359172</span></div><div><span style="font-family: 'Courier New', Courier, monospace;">user=> (area :rectangle 2 3)</span></div><div><span style="font-family: 'Courier New', Courier, monospace;">6</span></div></div><div><br /></div><div>This kind of polymorphism is so much intriguing that it is worth being captured with a macro. The macro eases the definition of polymorphic functions. What we add to the macro is the idea of a dispatch function. The dispatch function determines the identifier used as a key value for looking up the function in the map. It gives us some additional flexibility.</div><div><br /></div><div><div><span style="font-family: 'Courier New', Courier, monospace;">(defmacro defnpoly</span></div><div><span style="font-family: 'Courier New', Courier, monospace;"> ([name dispatch-fn map]</span></div><div><span style="font-family: 'Courier New', Courier, monospace;"> `(defnpoly ~name ~dispatch-fn ~map nil))</span></div><div><span style="font-family: 'Courier New', Courier, monospace;"> ([name dispatch-fn map default-fn]</span></div><div><span style="font-family: 'Courier New', Courier, monospace;"> `(defn ~name [& args#]</span></div><div><span style="font-family: 'Courier New', Courier, monospace;"> (apply</span></div><div><span style="font-family: 'Courier New', Courier, monospace;"> (~map (apply ~dispatch-fn args#) ~default-fn)</span></div><div><span style="font-family: 'Courier New', Courier, monospace;"> args#))))</span></div></div><div><br /></div><div>Don't worry if you do not get the details of the macro. Using the macro is straight forward. It captures a pattern of a <i>multiple choice construct</i> -- and that is what we are after.</div><div><br /></div><div>Using the macro, the definition of our polymorphic function <span style="font-family: 'Courier New', Courier, monospace;">area</span> looks like this; note how the area for a square is implemented:</div><div><br /></div><div><div><span style="font-family: 'Courier New', Courier, monospace;">(defnpoly area (fn [shape & args] shape)</span></div><div><span style="font-family: 'Courier New', Courier, monospace;"> {:circle (fn [self r] (* r r Math/PI))</span></div><div><span style="font-family: 'Courier New', Courier, monospace;"> :rectangle (fn [self a b] (* a b))</span></div><div><span style="font-family: 'Courier New', Courier, monospace;"> :square (fn [self a] (area :rectangle a a))</span></div><div><span style="font-family: 'Courier New', Courier, monospace;"> :triangle (fn [self a b] (* a b 0.5))})</span></div></div><div><br /></div><div>The dispatch function captures the previously mentioned strategy how a dispatch value is determined from a given set of arguments. It is the very first argument the dispatch is based on. Since the different functions implementing <span style="font-family: 'Courier New', Courier, monospace;">area</span> are called with the very same arguments as the dispatch function is called with, we need to capture the first argument called <span style="font-family: 'Courier New', Courier, monospace;">self</span> though it is ignored in the body of the functions. The use of <span style="font-family: 'Courier New', Courier, monospace;">self</span> might trigger a revelation: object-orientation is nearby.</div><div><br /></div><div><div><span style="font-family: 'Courier New', Courier, monospace;">user=> (area :circle 2)</span></div><div><span style="font-family: 'Courier New', Courier, monospace;">12.566370614359172</span></div><div><span style="font-family: 'Courier New', Courier, monospace;">user=> (area :square 2)</span></div><div><span style="font-family: 'Courier New', Courier, monospace;">4</span></div></div><div><br /></div><div>As you can see, no <span style="font-family: 'Courier New', Courier, monospace;">if</span>-statements are needed nor used in polymorphic functions. And that's exactly what the Anti-If Campaign is after: Use polymorphic functions, use the power of such a <i>multiple choice construct</i> whenever meaningful and possible. <span style="font-family: 'Courier New', Courier, monospace;">If</span>-statements are no adequate means to emulate multiple choice. Beyond the need of <i>binary choice</i>, <span style="font-family: 'Courier New', Courier, monospace;">if</span>-statements make code for <i>multiple choice</i> ugly, hard to maintain and less adaptable. As you can see, it is a breeze to add an implementation for <span style="font-family: 'Courier New', Courier, monospace;">:square</span> to <span style="font-family: 'Courier New', Courier, monospace;">area</span> -- no <span style="font-family: 'Courier New', Courier, monospace;">if</span> is required.</div><div><br /></div><div>One can do amazing things with polymorphic functions and a flexible dispatch mechanism. It embraces first argument type dispatch as is done in object-orientation. But there is more to it. Let us have a simple example for dispatching on the type of both arguments given to polymorphic function <span style="font-family: 'Courier New', Courier, monospace;">times</span>: </div><div><br /></div><div><div><span style="font-family: 'Courier New', Courier, monospace;">(defnpoly times (fn [x y] [(type x) (type y)])</span></div><div><span style="font-family: 'Courier New', Courier, monospace;"> {[Long Long] (fn [x y] (* x y))</span></div><div><span style="font-family: 'Courier New', Courier, monospace;"> [Long String] (fn [n s] (reduce str (repeat n s)))</span></div><div><span style="font-family: 'Courier New', Courier, monospace;"> [String Long] (fn [s n] (times n s))})</span></div></div><div><br /></div><div>The program is clear and succinct -- because there are no <span style="font-family: 'Courier New', Courier, monospace;">if</span>s. Polymorphic functions have their own beauty!</div><div><br /></div><div><div><span style="font-family: 'Courier New', Courier, monospace;">user=> (times 4 3)</span></div><div><span style="font-family: 'Courier New', Courier, monospace;">12</span></div><div><span style="font-family: 'Courier New', Courier, monospace;">user=> (times 4 "hi")</span></div><div><span style="font-family: 'Courier New', Courier, monospace;">"hihihihi"</span></div><div><span style="font-family: 'Courier New', Courier, monospace;">user=> (times "hi" 0)</span></div><div><span style="font-family: 'Courier New', Courier, monospace;">""</span></div></div><div><br /></div><div>Polymorphic functions are so much useful that Clojure has them already included. In Clojure, polymorphic functions are called multimethods.</div><div><br /></div><h3> Multimethods in Clojure</h3><div>Part of the fascination of Lisp-like languages such as Clojure is that they are extremely extensible. If you are missing polymorphic functions, you write yourself a short macro, and you have the feature and can use it. We demonstrated how easy that is.</div><div><br /></div><div>Clojure follows the tradition of Lisp and favors a slightly different model of defining a polymorphic function in your code. The polymorphic function is declared with <span style="font-family: 'Courier New', Courier, monospace;">defmulti </span>and its implementing functions are defined with <span style="font-family: 'Courier New', Courier, monospace;">defmethod</span>. This way, Clojure abstracts away the use of a map for polymorphism. It adds a layer of abstraction and removes a little bit of syntactic overhead we had in our solution. Other than that, <span style="font-family: 'Courier New', Courier, monospace;">defmulti</span> and <span style="font-family: 'Courier New', Courier, monospace;">defmethod </span>behave exactly like <span style="font-family: 'Courier New', Courier, monospace;">defnpoly</span>. See yourself, how close the definition of area is to our <span style="font-family: 'Courier New', Courier, monospace;">defnpoly </span>approach.</div><div><br /></div><div><div><span style="font-family: 'Courier New', Courier, monospace;">(defmulti area (fn [shape & args] shape))</span></div><div><span style="font-family: 'Courier New', Courier, monospace;">(defmethod area :circle [self r] (* r r Math/PI))</span></div><div><span style="font-family: 'Courier New', Courier, monospace;">(defmethod area :rectangle [self a b] (* a b))</span></div><div><span style="font-family: 'Courier New', Courier, monospace;">(defmethod area :square [self a] (area :rectangle a a))</span></div><div><span style="font-family: 'Courier New', Courier, monospace;">(defmethod area :triangle [self a b] (* a b 0.5))</span></div></div><div><br /></div><div>Multifunction <span style="font-family: 'Courier New', Courier, monospace;">area </span>is used exactly like our polymorphic function definition of <span style="font-family: 'Courier New', Courier, monospace;">area</span>.</div><div><br /></div><div><div><span style="font-family: 'Courier New', Courier, monospace;">user=> (area :circle 2)</span></div><div><span style="font-family: 'Courier New', Courier, monospace;">12.566370614359172</span></div><div><span style="font-family: 'Courier New', Courier, monospace;">user=> (area :square 2)</span></div><div><span style="font-family: 'Courier New', Courier, monospace;">4</span></div></div><div><br /></div><div>There is a lot more to say about multifunctions in Clojure, but I do not want to drift away from our starting point: the Anti-If Campaign.</div><div><br /></div><h3> Summary</h3><div>In the data structure of a map the concepts of <i>equality </i>and <i>choice </i>are inherently included. The interesting part is that a map provides a mechanism for multiple choice. That means that binary choice (being another word for <span style="font-family: 'Courier New', Courier, monospace;">if</span>, so to speak) is just a special case of multiple choice; that is why <span style="font-family: 'Courier New', Courier, monospace;">if</span> can easily be re-implemented using maps. To have a binary choice construct like <span style="font-family: 'Courier New', Courier, monospace;">if</span> at hand is useful and meaningful.</div><div><br /></div><div>The fun part is to utilize and explore the power of multiple choice with maps. It takes a simple step and the introduction of a dispatch function and we have polymorphic functions. Polymorphic functions are a very powerful control construct. They are easy to use, make code highly readable and flexible to adapt. Same does object-orientation. But the flexibility given by a dispatch function goes beyond (single type-dispatch) object-orientation.</div><div><br /></div><div>And that is the message of the Anti-If Campaign: <i>Learn to think in and use multiple choice constructs</i> -- be they provided in form of object-orientation or polymorphic functions (like in Clojure). If you use binary choice (i.e. <span style="font-family: 'Courier New', Courier, monospace;">if</span>) for multiple choice, your code will be messy and ugly. So, don't use <span style="font-family: 'Courier New', Courier, monospace;">if</span> to emulate multiple choice. Be the power of maps with you ;-)</div><div><br /></div><div class="blogger-post-footer"></div><div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=Vp2dfNnxUbw:d4XYT881LWs:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=Vp2dfNnxUbw:d4XYT881LWs:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>Clojure, visualization, and scripts</h1> <p>2012-05-24T07:25:49+00:00</p> Bit of a technical post for my own reference, about visualization and scripting in clojure.<br /><br /><h2> Clojure and visualization</h2>Being interested in clojure, a tweet by Francesco Strozzi (@fstrozzi) caught my attention last week: "<i>A D3 like #dataviz project for #clojure. Codename <b>C2</b> and looks promising. <a href="http://keminglabs.com/c2/">http://keminglabs.com/c2/</a>. They need contribs so spread the word!</i>" I tried a while ago to do some stuff in D3, but the javascript got in the way so I gave up after a while. But I was still pulled towards something html5+css rather than java applets as created by processing.org.<br /><br />Although still in a very early stage, C2 is already very powerful. Rapid development of visualizations is aided by the visual repl: the webpage localhost:8987 automatically loads the last modified file in the samples directory.<br /><br /><br /><pre>(ns rectangles-hover<br /> (:use [c2.core :only [unify]]))<br /><br />(def css "<br />body { background-color:white;}<br />rect { -webkit-transition: all 1s ease-in-out;<br /> fill:rgb(255,0,0);}<br />rect:hover { -webkit-transform: translate(3em,0);</pre><pre>fill:rgb(0,255,0);}</pre><pre>circle { opacity: 1;<br /> -webkit-transition: opacity 1s linear;<br /> fill:rgb(0,0,255);}<br />circle:hover { opacity: 0; }<br />")<br /><br />[:svg<br /> [:style {:type "text/css"} (str "<[CDATA[" css "]]>")]<br /> (unify {"A" 50 "B" 120} (fn [[label val]]<br /> [:rect {:x val :y val :height 50 :width 60}]))<br /> (unify {"C" 180 "D" 240} (fn [[label val]]<br /> [:circle {:cx val :cy val :r 15}]))]<br /></pre><br /><div class="separator" style="clear: both; text-align: center;"><a href="http://2.bp.blogspot.com/-eifqHnLmb5o/T70dxHevT2I/AAAAAAAAD-Y/qk7Pab0YFMk/s1600/Screen+Shot+2012-05-23+at+19.25.42.png" style="margin-left: 1em; margin-right: 1em;"></a></div><br />This bit of code draws 2 red rectangles and 2 blue circles. Hovering the mouse over any of the rectangles will move it to the right and change its colour to green; hovering over a circle will make that circle transparent. Some more scripts that I've used to build up simple things and learn C2 are on <a href="https://github.com/jandot/c2-samples">github</a>.<br /><br />Although interactions are not covered in C2 itself, simple transitions can be handled in the CSS part (see the example above). Brushing, linking and other types of interaction would be interesting to have available as well, though. But the developer Kevin Lynagh is very responsive.<br /><br />I haven't looked yet into how to run C2 without the visual repl; still on my to-do list. (<b>UPDATE</b>: see end of post)<br /><br /><h2> Clojure and scripting</h2>And today, I saw <a href="http://charsequence.blogspot.com/2012/04/scripting-clojure-with-leiningen-2.html">this</a>. Leiningen 2 will allow you to easily execute little clojure scripts without the whole setup of a project. Makes it amenable for pipelining just like you would do with little perl/ruby/python scripts. The completely-useless-but-good-enough-as-proof-of-principle little example below attaches some dashes to the front and stars at the back of anything you throw at it from STDIN.<br /><br /><pre>#!/bin/bash lein exec<br />(doseq [line (line-seq (java.io.BufferedReader. *in*))]<br /> (println (str "----" line "****")))</pre><br />Pipe anything into this:<br /><pre>ls ~ | ./proof-of-principle.clj</pre><br />Dependencies are now stored in ~/.mv2 rather than in the project directory, you can load libraries such as clojure like this:<br /><br /><pre>#!/bin/bash lein exec<br />(use '[leiningen.exec :only (deps)])<br />(deps '[[incanter "1.3.0"]])<br /><br />(use '(incanter core charts stats datasets))<br />(save (histogram (sample-normal 1000)) "plot.png")</pre><br />This also works in the interactive repl ("lein repl").<br /><br /><h2>Bringing the two together</h2>It's really easy to combine these two (after a pointer from C2 Kevin (Thanks!)). You need an additional dependency on hiccup to convert to html, but that's it.<br /><br />Here's a script that, when executed with "lein exec this-script.clj" will generate a html file with the interactive picture shown above.<br /><br /><pre>#!/bin/bash lein exec<br />(use '[leiningen.exec :only (deps)])<br />(deps '[[com.keminglabs/c2 "0.1.1"] [hiccup "1.0.0"]])<br /><br />(use '[c2.core :only (unify)])<br />(use 'hiccup.core)<br /><br />(def css "<br />body { background-color:white;}<br />rect { -webkit-transition: all 1s ease-in-out;<br /> fill:rgb(255,0,0);}<br />rect:hover { -webkit-transform: translate(3em,0);<br /> fill:rgb(0,255,0);}<br />circle { opacity: 1;<br /> -webkit-transition: opacity 1s linear;<br /> fill:rgb(0,0,255);}<br />circle:hover { opacity: 0; }<br />")<br /><br />(def svg [:svg<br /> [:style {:type "text/css"} (str "")]<br /> (unify {"A" 50 "B" 120} (fn [[label val]]<br /> [:rect {:x val :y val :height 50 :width 60}]))<br /> (unify {"C" 180 "D" 240} (fn [[label val]]<br /> [:circle {:cx val :cy val :r 15}]))])<br /><br />(spit "test.html" (html svg))</pre><br /><div class="blogger-post-footer"></div><div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=y3B_THH4kCc:xZrlCIIXq4k:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=y3B_THH4kCc:xZrlCIIXq4k:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>[lein-droid "0.0.1"]</h1> <p>2012-05-23T20:21:00+00:00</p> <div dir="ltr" style="text-align: left;"><table cellpadding="0" cellspacing="0" class="tr-caption-container" style="float: right; text-align: right;"><tbody><tr><td style="text-align: center;"><a href="http://3.bp.blogspot.com/--wa8mg9E35g/T71CemnE-4I/AAAAAAAAAVk/F-XYPDi6uRk/s1600/forever-in-love.png" style="clear: right; margin-bottom: 1em; margin-left: auto; margin-right: auto;"></a></td></tr><tr><td class="tr-caption" style="text-align: center;">Best friends forever.</td></tr></tbody></table>So, the very first release is done.<br /><br />Actually it wasn't much work to do since I posted here the last time. I added some fancy functions to take apart the AndroidManifest.xml file - it was necessary since starting the REPL requires the Internet permission, and I wanted it to be added automatically (if it wasn't not already there). Also I get the package name and the main activity name from the manifest in order to start the application from Leiningen. Not so necessary, but convenient.<br /><br />I managed to make all the project dependencies to get totally AOT-compiled for the development build. Now all of them are available in the REPL (as it turned out, they were not before).<br /><br />Added a "new" task to create Android projects using leiningen.new.templates library.<br /><br />Designed a fancy macro for running subprocesses (which form the 90% of my plugin). Now the subprocess runs silently by default, but if it's return code is not zero, then it prints out the errors. With the DEBUG flag enabled it prints the messages even if the process finishes successfully.<br /><table cellpadding="0" cellspacing="0" class="tr-caption-container" style="float: left; text-align: center;"><tbody><tr><td style="text-align: center;"><a href="http://3.bp.blogspot.com/-x836qvfAz2Q/T71CfKKsPQI/AAAAAAAAAVo/yEqUJvV1klM/s1600/wielding-parentheses.png" style="margin-left: auto; margin-right: auto;"></a></td></tr><tr><td class="tr-caption" style="text-align: center;">Android wields the parentheses <br />filled with the Power of Lisp</td></tr></tbody></table><br />Learned how to read passwords from the console in Java. The official javadocs suggest to fill the array of password characters with zeros as soon as the password is no longer needed. I wonder how many potentially-unsafe data Clojure leaves in memory when I convert the array to string and pass it around for a bit? And how long will it live before the GC cleans it out?<br /><table cellpadding="0" cellspacing="0" class="tr-caption-container" style="float: right; text-align: center;"><tbody><tr><td style="text-align: center;"><a href="http://1.bp.blogspot.com/-OqzHqDHBdXs/T71CkE2rtZI/AAAAAAAAAV0/I-Ev_oDL_qM/s1600/ic_launcher_hdpi.png" style="margin-left: auto; margin-right: auto;"></a></td></tr><tr><td class="tr-caption" style="text-align: center;">Hey there!</td></tr></tbody></table><br />Put together a little <a href="https://github.com/alexander-yakushev/lein-droid/wiki/Tutorial" target="_blank">tutorial</a> to explain how to start using lein-droid.<br /><br />And by the way - GSoC has officially begun! So things would only get more interesting. So stay tuned and enjoy the end of the spring ;). </div><div class="blogger-post-footer"></div><div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=odO1HjMxNYg:K0wERkh-PBo:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=odO1HjMxNYg:K0wERkh-PBo:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>Calculating Bell numbers in a single tweet</h1> <p>2012-05-23T12:48:40+00:00</p> <p>Recently I stumbled upon a white paper by Roger Sessions called <a href="http://www.objectwatch.com/whitepapers/MathOfITSimplification-103.pdf">“The Mathematics of IT Simplification”</a>. In this paper he describes an approach called synergistic partitioning, which is based on the mathematics of sets, equivalence relations, and partitions. One of the topics that comes up in this article is how many ways there are to partition N elements. The answer to this is well-known and called the Nth <a href="http://en.wikipedia.org/wiki/Bell_number">Bell number</a>.</p> <div class="wp-caption aligncenter" style="width: 159px;"><p class="wp-caption-text">The 52 partitions of a set with 5 elements</p></div> <p>The Wikipedia page that explains the Bell number also shows two implementations on how to calculate them, one in Ruby and the other one in Python. The Ruby version needs 17 lines of code, the Python version 12 lines. I have the peculiar habit of intriguing/annoying my colleagues at work with the statement that using Clojure the solution to any programming problem fits into one single tweet. In other words: 140 characters.</p> <p>I’ll start with my first attempt:</p> <p></p><pre class="brush: clojure;">(defn append-ele [s x] (concat s (list (+ x (last s))))) (defn next-row [s] (reduce append-ele (list (last s)) s)) (defn bell [n] (loop [n n s '(1) b s] (if (= n 1) (reverse b) (recur (dec n) (next-row s) (cons (last s) b))))) (println (bell 9)) </pre><p></p> <p>The first function (<em>append-ele</em>) appends a single new element to a row in the Bell triangle (explained in the Wikipedia article). In several ways this implementation is suboptimal since <em>concat</em> can only concatenate sequences, so I have to convert the single element to a list first. And what’s worse, appending at the end of a sequence is expensive since it’s computation is O(N), while prepending would only take one single operation.</p> <p>The function <em>next-row</em> calculates the next row in the Bell triangle. This row always starts with the last element of the previous row. I implemented this by a simple reduce over the elements of the previous row.</p> <p>And finally the function <em>bell</em> returns a sequence with the first <em>n</em> Bell numbers. I use a loop/recur to avoid a stack overflow. The sequence of Bell numbers is constructed in reverse order, so at the end (line 9) I have to call <em>reverse</em>.</p> <p>While this version is already pretty short (10 lines, without the printing), this still won’t fit in a single tweet. So the next step was to remove the first two helper functions and inline all the code into a single function. <strong>Warning</strong>: this is not good coding practice! With this disclaimer, here is the resulting code:</p> <p></p><pre class="brush: clojure;">(defn bell [n] (loop [n n s '(1) b s] (if (= n 1) (reverse b) (recur (dec n) (reduce #(concat % (list (+ %2 (last %)))) (list (last s)) s) (cons (last s) b))))) </pre><p></p> <p>Without the whitespace this implementation is 170 characters. Almost there! As you can see there are still some ‘expensive’ keywords like <em>concat</em> and <em>reverse</em> (6 and 7 characters!) and some annoying conversions from single numbers to lists. The only way to avoid this is to use a specialized data structure like vector instead of a sequence:</p> <p></p><pre class="brush: clojure;">(defn bell [n] (loop [n n s [1] b s] (if (= n 1) b (recur (dec n) (reduce #(conj % (+ %2 (last %))) [(last s)] s) (conj b (last s)))))) </pre><p></p> <p>Finally the code (without the indentation) fits into 140 characters. One caveat: I use <em>conj</em> which nicely appends an element to the end of a vector. However this behaviour of <em>conj</em> is not guaranteed. It is allowed to add an element anywhere in a sequence. When you use a list for example, the element is prepended. Because of this he above algorithm is O(N^2).</p> <p></p> <p>I will leave it as an exercise for the reader to implement the Bell number calculation as a lazy sequence so that you can use for example <em>(take 9 (bell))</em>. Have fun.</p> <br /> <a href="http://feeds.wordpress.com/1.0/gocomments/maurits.wordpress.com/661/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/godelicious/maurits.wordpress.com/661/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/gofacebook/maurits.wordpress.com/661/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/gotwitter/maurits.wordpress.com/661/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/gostumble/maurits.wordpress.com/661/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/godigg/maurits.wordpress.com/661/" rel="nofollow"></a> <a href="http://feeds.wordpress.com/1.0/goreddit/maurits.wordpress.com/661/" rel="nofollow"></a> <div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=Gs8SF8HdaS4:w8ZJEiLXx8c:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=Gs8SF8HdaS4:w8ZJEiLXx8c:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>Generating HTML with Clojure</h1> <p>2012-05-23T11:48:25+00:00</p> <p>[It's been a while ... I'm currently inbetween contracts and this has given me the chance to focus on writing some Clojure code.]</p> <p>As I'm between contracts I'm working on a web application for commuters. It's currently Postgres on the back end (which I am going to migrate to MongoDB) and Clojure for the application.</p> <p>When building web pages I want something that allows me to get the static pages right first and then make them dynamic, rather than the common approach of tweaking the dynamically generated pages until they look right. In Clojure, you can do this with the Enlive library, written by Christophe Grande.</p> <p>Today my copy of Clojure Programming arrived; Christophe is one of the authors and it has a section on Enlive, which has been really helpful.</p> <p>I've been trying to figure out how to generate a drop-down list and it turned out to be easier than I expected. Here's the code:</p> <pre class="Clojure brush:">(ns scratch.enlive.test1 (:require [net.cgrand.enlive-html :as h])) (def select-template "<select> <option>baz</option> </select>") (defn options [option-values] (h/sniptest my-select [:option] (h/clone-for [option-value-map option-values] (h/do-> (h/set-attr :value (:value option-value-map)) (h/content (:display option-value-map)))))) (options [{:value "one" :display "two"} {:value "three" :display "four"}]) </pre><div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=_gytFwdBpEI:T6gI0Jt1RYQ:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=_gytFwdBpEI:T6gI0Jt1RYQ:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>Generating HTML with Clojure and Enlive</h1> <p>2012-05-23T11:48:25+00:00</p> <p>[It's been a while ... I'm currently between contracts and this has given me the chance to write some more Clojure code.]</p> <p>My side project is a web application for commuters. The database is currently Postgres (which I am going to migrate to MongoDB) and I'm using Clojure for the application.</p> <p>When building web pages I want something that allows me to get the static pages right first and then make them dynamic, rather than the common approach of tweaking the dynamically generated pages until they look right. In Clojure, you can do this with the <a href="https://github.com/cgrand/enlive" rel="nofollow" target="_blank">Enlive</a> library, written by <a href="http://clj-me.blogspot.co.uk/" rel="nofollow" target="_blank">Christophe Grande</a>.</p> <p>I have read Clojure in Action, Programming Clojure, and dipped into the Joy of Clojure. Today my copy of Clojure Programming arrived, co-authored by Christophe with <a href="http://cemerick.com/" rel="nofollow" target="_blank">Chas Emerick</a> and <a href="http://briancarper.net/" rel="nofollow" target="_blank">Brian Carper</a>. It it sub-titled "Practical Lisp for the Java World" and the practical approach is apparent; it has a section on Enlive which has been really helpful.</p> <p>I've been trying to figure out how to generate a drop-down list and it turned out to be easier than I was expecting once I'd read the book. Here's the code:</p> <pre><code class="brush: Clojure"> (ns scratch.enlive.test1 (:require [net.cgrand.enlive-html :as h])) (def select-template "<select name=\"test1\"><option value=\"bar\">baz</option></select>") (defn options [option-values] (h/sniptest select-template [:option] (h/clone-for [option-value-map option-values] (h/do-> (h/set-attr :value (:value option-value-map)) (h/content (:display option-value-map)))))) (options [{:value "one" :display "two"} {:value "three" :display "four"}]) ; => "<select>\n <option>two</option><option>four</option>\n </select>" </code></pre> <p> The sniptest function is a great help to be able to try things out in the REPL. That [:option] vector is a selector, and the result of sniptest is to replace any elements matching that selector with the result of the clone-for. </p> <p> I think I am going to enjoy using Enlive. </p><div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=umYXYG6IrJw:Ak51KP_o_ao:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=umYXYG6IrJw:Ak51KP_o_ao:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>The Clojure Library Ecosystem</h1> <p>2012-05-23T00:46:50+00:00</p> <p>Clojure’s library ecosystem can be a source of confusion for new users. This quick overview will help to orient new Clojure programmers to the current state of the library system, with pointers to resources for further information.<span id="more-590"></span></p> <h2>Leiningen</h2> <p>Most Clojure projects use <a href="https://github.com/technomancy/leiningen/" target="_blank">Leiningen</a> as their build and dependency management system. Project dependencies and their required versions are placed in a file called <code>project.clj</code>, and Leiningen takes care of downloading them. Leiningen also creates JARs of the release versions of your project, and can bridge to Emacs’ SLIME mode, run a REPL at the command line, and so on. Many plugins exist to extend Leiningen’s functionality for other things like testing and deployment.</p> <p>Under the covers, Leiningen uses <a href="http://maven.apache.org/" target="_blank">Maven</a> for dependency management. Maven is one of those ridiculously over-engineered Java projects that we all love to hate where you have to write 100 lines of XML boilerplate around 2 lines of actual project-specific configuration data. Fortunately, Leiningen insulates us from all of that.</p> <p>Users should be aware that, as of this writing (May, 2012), Leiningen is about to release version 2.0, which uses a slightly different <code>project.clj</code> format. Some Leiningen plugins have not been updated for the new format. This is easy enough to work around if you know that there has been a specification change. In particular, many <code>:dev-dependencies</code> that affect Leiningen itself have to be moved to the new <code>:plugins</code> key.</p> <h2>Clojars and GitHub</h2> <p>Most Clojure libraries are provided in binary JAR format on <a href="http://clojars.org/" target="_blank">Clojars</a>, and have their source code hosted on <a href="https://www.github.com/" target="_blank">GitHub</a>.</p> <p>Clojure developers frequently face the situation where some critical bugfix or new feature exists only on somebody’s GitHub fork, but not in the mainline repository. The best option in this case is to get the maintainer to push a new official release with the required changes, but this is not always possible. If the project has a slow release cycle, or if the original developer is not very into the project, it can be months between the creation of patches in a fork and their release from the mainline repository to a new version on Clojars. We have a few options in that case.</p> <p>For development, it can be convenient to use the <a href="https://github.com/tobyhede/lein-git-deps" target="_blank">lein-git-deps plugin</a>. This extends Leiningen to allow it to download dependencies from GitHub into a hidden directory in your project. This is something of a fragile hack, though. If the subproject has any dependencies, they will not be checked out by Leiningen — you have to manually install them in the parent project. Worse, the code on GitHub can change at any time (unless you specify a particular release). If you redeploy your code in the future, you might wind up with a broken project. If it’s impractical to get the maintainer of a library to produce a new official release, it’s best to fork the library and make your own stable release.</p> <p>If you just want to use it locally, check out your fork to your local machine, bump the version number, and do <code>lein install</code>. Within your organization, you can easily host a private Maven repository. If you want to deploy publicly, you can push a forked release to Clojars with a different group-id. Detailled instructions on how to do these things can be found <a href="https://github.com/technomancy/leiningen/blob/stable/doc/DEPLOY.md" target="_blank">in the Leiningen documentation</a>.</p> <div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=tgvLyglStjE:NTqr6ZmlDpI:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=tgvLyglStjE:NTqr6ZmlDpI:qj6IDK7rITs"></img></a> </div> </article> <article> <h1>Senior Software Engineer at Mediaplex (Full-time)</h1> <p>2012-05-23T00:19:36+00:00</p> <p>Why join us?</p> <p>Are you looking to join an organization with a start-up feel that has the backing of an established, stable, public company? Do you want to work in a small group of exceptionally sharp engineers in a challenging and rewarding role while having further opportunities to grow your career? If so, we’d like to meet with you.</p> <p>We are looking for a strong Senior Software Engineer to join our ad server infrastructure team. In addition to contributing to our current core technology platform, you will help build a high volume Real-Time Bidding (RTB) system from the ground up.</p> <p>Your Mission</p> <p>Thrive in a small team environment where you’ll have the opportunity to showcase your ingenuity and influence the direction of our products. </p> <p>Is this you?</p> <p>• 7+ years experience in software development</p> <p>• Experience with Java-based web/app server implementations (Tomcat, Jetty, etc.)</p> <p>• Well-versed in internet protocols and paradigms (HTTP, REST, etc.)</p> <p>• Recent experience or a dedicated interest in functional programming</p> <p>• Desire to enhance and support large, complex systems in a global production environment</p> <p>• Experience with SQL (Oracle, MySQL preferred) and NoSQL (Cassandra, Hbase, MongoDB, Riak, etc.) and big data (Hadoop)</p> <p>• Good communication skills</p> <p>• Confident in a Linux-based development/production environment (command line tools, shell scripting, etc.)</p> <p>• Testing and documentation skills</p> <p>• CS/Math degree or equivalent real-world experience</p> <p>Pluses:</p> <p>• Open source contributions</p> <p>• Clojure, Erlang and/or Scala experience</p> <p>• C/C++ experience</p> <p>• Experience with internet advertising</p> <p>• Strong debugging/troubleshooting skills in complex architectures</p> <p>If you are looking to join an expanding global company that still maintains that small start-up feel, we’d love to hear from you!</p> <p>Get information on <a href="http://functionaljobs.com/jobs/108-senior-software-engineer-at-mediaplex">how to apply</a> for this position.</p><div class="feedflare"> <a href="http://feeds.feedburner.com/~ff/clojure?a=4FyCRHtROkY:OIeS78bjjc0:I9og5sOYxJI"></img></a> <a href="http://feeds.feedburner.com/~ff/clojure?a=4FyCRHtROkY:OIeS78bjjc0:qj6IDK7rITs"></img></a> </div> </article> </main></body></html>

Planet Clojure