Category: Clojure


funcjureI’ll soon be starting a new permanent job, and in preparation I’m making it clear what is my prior intellectual property. In this case, it’s not so I can make “oodles of money” in the future, but it’s actually so I can release it as Open Source.

So what I’ll be explaining here is not something I’ve finished, but an idea which I’ve actually been playing around with for a year or so, but never gotten around to fully implementing. This will also help bring together my thinking on this and hopefully inspire me to really get going on this project :-)


What is funcjure?

funcjure is a “functional syntax wrapper” around Clojure. What do I mean by that? Well, Clojure is a great language, especially if you’re either used to or prepared to adapt to prefix notation. ie instead of typing 1+1, you type (+ 1 1) which although relatively easy to understand, can get a bit harder as things get more complex, like 9+5*7/4+62/6 which would translate as (+ 9 (*5 7) (/ 62 6) etc…

The logical question is Why? (do I have to type prefix notation) The Clojure and Lisp people will say “well, that’s the way it is, so just get used to it”, which I’m fine with as I wrote my first Lisp program over 3 decades go. Even still, I would prefer to use infix notation (which is what we’re taught for maths) and see no reason why we shouldn’t as computers are great at doing the sort of rote translation required to convert infix to prefix notations.

Clojure is a great language, which also has a fantastic ecosystem and community, and is written in Java which has a HUGE ecosystem. Furthermore, Clojure can call Java code, which has helped tremendously by giving Clojure “out of the box” access to so many libraries and products. Finally, because Clojure is a Lisp, its strong point is Symbolic Manipulation which is exactly what is required for translating infix to prefix structures in order to implement funcjure!

What would this look like? Let’s take some typical Clojure and then show what it would look like in funcjure:

"Hello World!"            ; Minimal "Hello World!"
; "Hello World!"

(println "Hello World!" ) ; Standard "Hello World!"
; println("Hello World!)
; Clojure((println "Hello World")) ; Execute some Clojure code
(def a "test")            ; Define a variable
; a="test"

(def mylist '(1 2 4 5 6)) ; Define a variable list
; mylist='(1 2 3 4 5 6)

(println a mylist)        ; Print our variables
; println(a mylist)

(first (rest '(1 2 3 )))  ; Get the 2nd element of the list
; first(rest('(1 2 3)))

(.println System/out "Hello World from Java!")
; System.out.println("Hello World from Java!")
; or Java(System.out.println("Hello World from Java!"))

(defn factorial           ; Now let's do the classic Factorial function
  ([n]                    ; when only one argument is passed in
    (factorial n 1))
  ([n acc]                ; when two arguments are passed in, with recursion
    (if  (= n 0)  acc
    (recur (dec n) (* acc n)))))
(factorial 6)             ; And test it
; factorial(n) = factorial(n 1)
; factorial(n, acc) = if((n==0), acc, recur(dec(n), n*acc))
; factorial(6)

The overall purpose is to make code much more accessible and ‘natural’ to write as we’re essentially taught infix notation as our “second language” when we study even the most basic mathematics. None of this is really new – in the beginning, things look like our old friend BASIC, with direct assignment and loose typing, which easily map to Clojure. You’ll also notice that access to Clojure and Java is provided by the respective functions. Speaking of functions, these are written similar to Prolog and other languages (eg Erlang) which allow for “pattern matching” in function definitions. In the beginning, the capabilities would be mapped directly to Clojure (as shown above), but eventually it would be nice to go to a full Prolog style, so the factorial function could be written like

factorial(0) = 1                ; The base termination case
factorial(n) = n*factorial(n-1) ; Iteration by recursion

which I think is way more elegant.

That’s about it for this post, as this really contains the base concepts for what I’d like to do. There’s obviously a lot more scope and subtlety to this, some of which I’m aware of and probably a lot more which I’m not, but I personally would much prefer to use a language like this and have access to Clojure and Java when needed for efficiency or easy code porting.

What do you think? All comments / suggestions / critiques would be gratefully accepted as I haven’t really done much more work than this, other than having a 1/2 working translator for this syntax which I’m going to (hopefully) get to work on in the next few weeks before I start my job.

Back in Australia


WOW! I just realised that it’s been a year since I did a blog post. I knew it had been a while, but I figured around 6 months max… Well, I suppose I needed it, and the good news is that I’M BACK!

I’m not going to go in to what has transpired over the past year since an agile adoption, as it’s quite involved and will come out in some successive posts, but will focus on where I am now and what my Posting Plans are.

Near the end of last year we started planning a return to Australia after almost a decade in the UK – what a BLAST! So many lovely experiences, people, places and new friends :-) Eventually though, it was time to return to Australia as it really is my home and although I may have a few gripes about it, Australia really is an amazing place and as the old cliche goes: I now really appreciate how lucky I am to live in this country after being away so long. That shot above is from my local beach which is 3 mins drive, and I can get in to the city (in the distance) in around 1/2h with a walk and public transport – that’s a pretty good lifestyle.

So what’s in the pipe? A much more varied mix than when I started out doing just “software stuff”:

  • Reflections on life in the UK and Europe
  • Observations on life in Australia now I’m back
  • Reviews of gadgets
  • Travelogues as I explore my own country – now I’ve probably seen more of Europe than I have of Australia, so it’s time to correct that
  • Process  – yes, I’m still on the agile path
  • Architecture – looks like that will be my primary area of work still
  • Software – which I’m gradually getting back in to, with the current focus being Clojure
  • Probably the odd bit of music or photography to round things out
  • Anything else anyone would like me to write about…


Welcome 2015!

London Fireworks 2015M25 Carpark

It’s been quite a while since I’ve posted much, mainly due to a contract which requires me to drive on the M20 and M25 (aka “the carpark” for those outside the UK) and as a result, I just don’t seem to of had the time and energy…

Javelin TrainOh, how I long for those lovely trains, and will never complain about a 30 or even 60 minute delay – the worst I’ve had in a car is a 1h trip taking 4h!!!

I look forward to getting on something where someone else is doing the driving so I can use my time effectively

Amazingly, it seems like only 7% (4.5 Million) people in the UK use public transport. Given that nearly 1/3 (22 Million) live in the South-East, where transport is generally pretty good, that seems pretty low. No surprise given the number of people on the motorways – I’ll be happy to take one more off them next contract.

So what’s up for 2015 for me and this blog?

For one, I plan to start getting back in to a bit more of a rhythm, both with my posts and the associated (play) work (generally outside “real work”), and I will continue to post based on my experiences – recent and past…

theme : ecologyWhat are the themes though? Here’s a list of where I’d like to go:

  • Lifestyle & Reviews
  • Process & People & ScramJet
  • Clojure
  • Architecture, including Enterprise & SOA aspects

in no particular order. I won’t get in to specifics as much of it is not yet planned, or I’m working on it but don’t want to reveal it until I have enough meat on the the bones so I can be sure it will fly.

teaserHere’s a few teasers though based on posts I know I’ll write or have in draft form:

  • Review of Bob Marshall’s “Thinking Different” happening last year
  • Review of the: BMW i3 electric car; Samsung Galaxy Alpha
  • Corporate Subversion – in a positive manner of course :-)

and that’s really just the “boring stuff” – there should be some very interesting posts coming as I hit my stride.

I hope you’ve all had a great XMas & New Year break and look forward to some great interactions in 2015!

Changearc – the thinking person’s RiczWest ;-)

Today I’m (@RiczWest) starting a new twitter account. It’s called ChangeArc. For those who follow me, you’ll recognise this as my “Blog Name” – so what’s the purpose?

Simple – when I started using Twitter, it was primarily as a bookmarking tool. To some extent I still use it as such, but also for so much more…

There’s one problem though – as I look at a lot of content, that means a lot of tweets, and not everyone likes that, including me! There are a number of great people I’d like to follow, but I can’t because they tweet too much.

To that end, I’m going to start a much lower volume (only a few tweets per day) account which is ChangeArc. So what can you expect apart from less tweets? Extremely high quality tweets that will include any posts I do.

I don’t know how this will evolve, but it will be interesting to see…

EuroClojre – Day 2

Wow! I thought Day 1 was Great – Day 2 just as good, including some great but “enterprise geeky” topics like Enterprise Integration in Clojure and A Perfect Storm for Legacy Migration ;-) Plus, we had Stuart Halloway’s…

Keynote – Narcissistic Design


  • Stuart Halloway
  • Examples
    • Build Tools
    • ORM
  • Advanced
    • Integrating narcissism and agile practice
    • Technologies to avoid
      • Functional languages & databases
    • Never eliminate complexity, automate around it
    • Manage by pull request, because code is the first and best unit of discussion
  • Top 10
    1. Use OO, and don’t forget those setter methods!
    2. Prefer APIs over data
    3. Start with DSLs
      – Nothing says “screw you” like a DSL
      – JVM
    4. Always connect (and never enqueue)
    5. Create abstractions for information
      – Encapsulate!
    6. Use static typing across subsystem boundaries
      – Exceptions
    7. Put language semantics on the wire
      – Focus on programming rather than data languages
    8. Write lots of unit tests
      – Example Based Testing
      – TDD
      – Always be coding
      – Never get on the hammock
    9. Update information in place
      – The one thing about OO: gives you all the complexity but no history
    10. Leverage context

Using Clojure to Serve The Internet of Things


  • Kontiki
    • Lightweight OS
  • Nest
  • How do I get iot on my CV?
    • Dev kits
      • mBed
      • Electric imp
      • RasberryPi
      • Arduino
    • Beagle bone
    • Open data sets
    • Web / Mob apps
  • Xively
    • LogMeIn
    • Went from Ruby
      • To Clojure
        • Order of magnitude improvement!
  • Architecture of “thermometer”
    • Twitter
      • Clojure hero ku
        • Clojure Xivi
          • ?
  • IoT
    • 1.1b PCs
    • 2mm2 32-bit computer with wiFi for $1
      • 32kB RAM
      • 128kB Flash
      • Radio
      • Weightless – OS?
        • Batt
          • 50 bytes/h for 10y on 2 AA Batt!
    • 5.8b mob
    • 1T Things
    • Main challenges
      • Discovery
      • Directories
      • Provisioning
      • Security
    • Should take off due to economies of scale
    • Massive Data Volumes
      • Motor
        • 1Gb data / h

Newspaper Massacre!


  • Conways Law
  • Daily Mail
    • Mail Online
      • Largest online newspaper
        • Serve 154Bn images!
        • Cached by Akamai
        • Serve 1000 articles/s
      • Very long home page
  • Mobile
    • Gamechanger
      • Personalisation
        • Trying to scale
  • Published messages from Legacy to Topic
  • Challenge
    • Render the homepage
      • No caching
      • Response <300ms
  • Mustache
    • Templates Library
    • Themes
      • e.g. Mobile
  • Libs / Projects
    • Memcached
    • Mule
    • Reddis
    • Riemann
      • Graphite
      • Logstash
  • Ppl
    • @clifcunn
    • @jonpither
      • Pitheringabout
  • Config
    • Avout
      • Wrapper around Zookeeper
  • Services
  • Built a library around software infrastructure
  • Future
    • Rewrite everything
      • ~13kLOC
  • Devs sit next to newsroom
    • E2E Ownership
    • Responsibility
  • Terrible Legacy
    • Using Spring

(into reduce transient)


  • Clojure.core/ancestors
    • (Ancestors (class []))
  • Libraries
    • avl.clj
    • core.rrb-vector
  • Guy Steel Talk
    • About sequential reduction

Lightning talks: Literate Programming, Bare Metal Lisp & Templating


In search of workflow nirvana: Clojure, Emacs, Org

    • Rich Hickey
      • Ant Simulation
    • Org – mode in EMACS
    • Literate Programming
      • “is what you need to rise above the ordinary level of achievement”
    • Pedestal
    • Working on functional CMS system

Lithium: a small Clojure-inspired Lisp on the bare metal

      • Compiles to x86
        • No runtime dependencies
      • Fluchtpunkt Lisp
      • Paper: An incremental approach to compiler construction
      • Movitz
        • Similar for Common Lisp
      • Synthesis: an efficient implementation of fundamental operating system services

Templating In Clojure

    • Hiccup
      • HTML as a data structure
      • No real separation
      • Good if full stack devs
    • clj-jade
      • Successor to HAML
      • Use Jade for J
      • Or moustache
    • Enlive
      • Transformations of HTML
      • Good for front-end
      • CSS Selector based
        • Can break transformations
      • Lacks HTML abstraction
        • + Hamilito

Enterprise Integration in Clojure


  • clumsyjedi @ GitHub
  • Enterprise Integration Patterns
  • Looked At
    • Mule
      • Not used – too many problems
    • Camel
      • HolyGrail
    • Use
      • core.async
      • + Threaded Macros
    • Lamina
      • Event Stream Processing Library
        • Superset of EIP
      • Rysome
    • Storm
      • Java / Clojure Hybrid
        • Chosen
    • ClamQ
      • Clojure i/f for ActiveMQ
    • EEP
      • Good visualisation
  • Areas of Interest
    • Systems Integration
    • Business Rules Capture
    • Distributed Systems Orchestration
  • Using Vim
  • Beyond Patterns

A Perfect Storm for Legacy Migration


  • Twitter Storm
  • Clojure
  • Distributed runtime
    • For “eXtreme Processing”
  • Apache Thrift
  • Nimbus
  • ?
  • Gives
    • Stream Processing
    • Realtime Analytics
    • Continuous Computation
    • Distributed RPC
  • Concepts
    • Bolt
    • Spout
    • Topology
    • Grouping “field”

EuroClojure – Day 1

I’ll be putting some notes / mind maps up here from EuroClojure over the next two days. In the “agile spirit” I’m including my notes fairly raw below and may refine them later… For the meantime, in case you weren’t able to attend EuroClojure, here is a summary of some of the fun you’ve missed ;-)


EuroClojure Keynote MindMap

Critical Theory

  • Nomad
  • Rhizome
    • “Interconnectedness of Things”
  • State
  • Information
    • Collapse of Abstracton to Reality
      • Brazilia


  • Production methods
    • Prussian “Scientific Forestry”
      • Create Flawless Abstractions
    • vs Organic Forests
  • ~ Forest


  • Techne
    • Timeless
  • Metis
    • Cunning
      • Local
      • Contextual
      • Nomadic


  • Patterns of Software
  • Fictions and the aleph
  • Data and reality
  • Seeing like a state
  • Simila and simulation
  • Invisible cities


  • The Quality without a name
    • Contextual
  • Richard Gabriel
  • Pattern Language
    • To express patterns that were observed (locally)

Gerald Weinberg

  • An Introduction to Systems Thinking
  • Heuristic Devices don’t tell you when to stop

Make your own Lisp

Make your own LispBODOL

  • Homoiconic
  • Immutable
  • Typed
    • Robin Milner
    • Example
  • Pure
  • Makes HN Caremad
  • Pattern Matchinng
    • Used core.logic


  • Mark Engelberg
  • EBNF
    • Or Parse Combinators




  • Core Match
    • Not used as specific to Clojure…?
  • Lispkell
    • Also Lisp + Haskell

Life in a Browser

Life in a Browser

Genetic Algorithms

  • Breed s-expressions


  • Tree handling Library


  • Complexity – a guided tour
  • Complexity explorer
  • Stephen wolfram
    • A new kind of science

Biologically inspired computing – Artificial Life Project

  • In browser with core.async
  • Enlil
    • Head Mesopotamian god




Free your data with RFC2616

  • Http 1.0
    • + Patch
      • Liberator doesn’t handle
    • + WebDav
    • Almost 40 decision points for all status codes

Only 1 use in prod – Clojure library

  • Implement REST Resources
    • On the server side

~ 1/3 LOC Takes care of most of the status code processing

  • Uses “standard” from http flow diagram
    • See web site

Automatically converts your data to JSON or EDN

Creative Machines

  • Creative Machines

    Book: Creative Music

    • Death = Entropy Chaos*
  • Recombinance
    • Creativity does not occur in a vacuum


    • Serendipity

    Learning + Inference + Knowledge

    • Canon Builder
    • Association Network
      • Like Neural

    New neural networks

    Cognitive Bias


    • Death Dance
    • Aaron
      • Painter
      • Howard Kern / Cohen
    • Music (overtone)
      • Markov Chains
      • Neural Nets

    David Cope

    • Emily Howell
      • Music


    • Can happen by
      • Combination
      • Exploration
      • Transformation
        • Reflect on System Rules
        • And Change those Rules
    • Psychological
    • Historical


  • Functional 3D Game DesignNeed to get everything done in 16ms

    • Side effectual
      • => !used

    Based on JMonkeyEngine
    Probably go to LWJGL
    Use Quarternions

    • 3 imaginary numbers
    • 1 real number

    Functional Reactive Programming
    Modelling both Continuous and Discrete Data changes

Common Clojure Smells

Common Clojure Smells

Martin Fowler & Kent Beck

  • Refactoring

Long parameter lists

  • Underlying issues

Clojure specific smells

  • Locally scoped atoms
  • Magic Keys
    • aka Data structure coupling
    • Hard to figure out the cost of change of key names, data types etc…
    • Keep data aware fns together (defrecord?)
  • Indirection by partiality
  • Macromania
  • Parents Proliferation
    • aka Over-nesting
    • Trying to do everything in one expression
    • Balance between tenseness & readability
  • Lazi-itis
    • Excessive use of lazy evaluation
    • Many discrete steps with a final one that executes the seq
    • Consider pulling things in to coarser-grained steps to avoid long pipelines

Kent Beck

  • Smalltalk practice

Jennifer Smith

Do OO Heuristics apply to Functional code?

Is Java the new C?

JavaLogoI started programming in Java a few years after it was released. I had been doing C++ for a number of years and just come off a C++ project which failed because they (who were a pretty good team of programmers) couldn’t scale it because of the two common killers: Threads and Memory Management. Near the end I was reading James Gosling’s original paper on Java which addresses the major problems of C++ and explaining how Java addressed them. I was obviously quickly sold! As a result I spent over a decade programming in Java and J(2)EE, in the beginning implementing (mostly web) projects way faster than the “C++ laggards” could.

Now, I’ve been doing Solution and SOA Architecture, occasionally whipping up a prototype in Java, or doing some Perl but quite often working with WSDL, XSD’s and just plain models. Recently though, I’ve been playing around with Clojure in my own time and am amazed at how much fun it is. It really reminds me about my early experiences with Java, but that would be the subject of another blog post…

Recently it has struck me just how many languages have versions or been constructed to run on the Java JVM. A list from Wikipedia shows:

Java LanguagesThat’s quite a few languages! What’s more, a number of them have plugins to an IDEs such as IntelliJ or more commonly eclipse. It struck me that these languages were effectively using Java and often IDE’s as a runtime / development platform, much like many high level languages used C.

Which begs the question – where is Java headed in the long-term? Yes, they’re adding Lamda’s in Java 8, but why would I want that when I can work with Clojure which has had this from the beginning and has a whole bunch of good extra stuff… Is it destined to become a “low level language and environment” upon which more sophisticated languages will be built?

The Almost Unbearable Lightness of LightTable

Note: This post is in Draft, I’ll be updating it a bit more…

LightTableSeesawAs I’ve been tweeting, I’m very interested in LightTable, the amazingly cool IDE being developed by Chris Granger @ibdknox and his gang. It’s a bit like the black spaceship from Hitch-Hikers Guide To The Galaxy though: “It’s the weird colour scheme that freaks me. Every time you try to operate one of these weird black controls, which are labeled in black on a black background, a small black light lights up black to let you know you’ve done it”. The next major release (in a month or so) will be addressing “user experience”, but in the mean time, what if you want to give it a serious try?

That is what the rest of this post is going to try and help you do also – get LightTable up and running so you can incorporate other projects and frameworks, which is really needed if you’re to proceed beyond trivial playing with it. But first, a warning from our sponsors (that’s me :). The version on LightTable says it all – 0.2.7. If you want a seamless install / development experience, especially if you have other installations of Clojure, IDE’s, lein, … then it’s probably best to come back later… They’re working quickly to address things, but this is a Real Agile Project that released very early and is now releasing often, so major kudos to them for doing so!

Finally, for some context, I’d rate myself as an “Enthusiastic Clojure Amateur” – I don’t do it for a day job, but I know my way around Unix, Maven, (now) Lein and Clojure through other environments. If you’re at this level or above then this post could be for you, and hopefully save you some time and frustration. You should also note that I use a Mac (is there any other platform to use for serious development? ;) so these instructions assume that. I won’t be doing a Windows post of this, but if anyone wants to then feel free to copy and change what I’ve written.

There are 3 key activities for setting up the latest version (0.2.7 or above) of Clojure:

  1. Clean Installation of Lein2
  2. Clean Installation of LightTable
  3. Creating a LightTable Project with Dependencies using Lein2

Note: I’m assuming you’ve got Maven 2 running, because you’re some sort of Java dev – I may add instructions for this later…

I’m sure all of these issues will be addressed in subsequent releases, but for the meantime, here’s how I did it – Note: it’s assumed that you’ve installed to your local user. If this is global (Unix) or Windows you’ll have to use different paths.

1. Clean Installation of Lein2

LeiningenThis was probably the most difficult and time-consuming thing to work out as I was running a version of Lein 1 that I’d installed ages ago, which is an absolute no-no. LightTable won’t work with this configuration and give you all sorts of weird errors. Whatever version of Lein you’re running it’s probably best to clean out your Maven directory:

rm -r ~/.m2/*

If you’re running an “old version” 1.x of Lein you’ll have to upgrade, which means that you should clean out your .lein directory:

rm -r ~/.lein

Then you’ll have to do a “Bootstrap Install” of Lein2 which isn’t that hard. Firstly, remove you’re old shellscript which in my case was in my ~/bin directory that is on my Unix path:

rm ~/bin/lein

Github LeiningenThen you’ll need to get the latest and greatest version of Lein 2.0.0 – this matters, as the default when you grab it from GitHub is the 2.1-SNAPSHOT (at this time of writing) version which is on the “master” branch, but unfortunately this won’t currently work with LightTable and give you weird connection errors. I originally got this, then changed it to Stable (2.0). In my environment, everything is in ~/Gits.

The final step for this is to then install Lein2:

cd ~/Gits/leiningen
lein install
lein version
>> Leiningen 2.0.0 on Java 1.6.0_37 Java HotSpot(TM) 64-Bit Server VM

2. Clean Installation of LightTableLightTableIcon

Once you have the right version of Lein2 going, it’s actually pretty easy to get LightTable going either if you haven’t installed it or are running an earlier version. To reset your configuration, just remove your .lighttable directory and contents:

rm -r ~/.lighttable

If you don’t have a recent version of LightTable, i.e. your icon doesn’t look like the above one, then you’ll need the latest installation of LightTable, which is pretty easy – just go to and download the correct launcher

Once you’ve reset your configuration, just run LightTable, it should then get the latest version and tell you to restart. When you’ve done this you can check the version from the “command line” at the bottom by typing “version” which should show 0.2.7 or whatever the latest (higher) version is. If it’s less then somethings gone wrong – Maybe you didn’t delete the entire directory? Maybe you have an old version of the launcher? You’ll have to do some digging if this is the case…

3. Creating a LightTable Project with Dependencies using Lein2

Now you have the right infrastructure set up, it gets very easy. To create a new project, you just create a default template:

cd ~/Projects/LightTable/
lein new guitesting

start up LightTable and connect to your project


during which you’ll see connecting and retrieving messages


and hopefully a brief connected message


If you get any blue error windows popping up on the left, then something has gone wrong, probably with your installation of Lein2 so you should go through and check the above process again.

Ah, but there is “one more thing”, which was the key capability I was looking for originally with LightTable, and that’s the ability to include extra projects / dependencies. Now that you’re up and running, this should be comparatively easy. You just add whatever you want to your project.clj, probably using LightTable now you have it running

(defproject guitesting "0.1.0-SNAPSHOT"
  :description "FIXME: write description"
  :url ""
  :license {:name "Eclipse Public License"
            :url ""}
  :dependencies [[org.clojure/clojure "1.4.0"]
                 [seesaw "1.4.0"]])

which in my case was seesaw that is a development framework for Swing GUI’s that I talked about in my previous post on Easy UI development in Clojure with Seesaw. If you have an instance of LightTable running then you should quit and re-start it to pick up the new dependencies when you connect and that’s it! You should now be able to use LightTable like you see on all the latest articles and videos

Finally, I will be doing an “Unbearable Lightness of LightTable” when LightTable progresses more in installation to the stage where the above instructions will not be necessary. In the mean time, I hope the above has helped you if like me, you’ve been looking at all the latest LightTable videos and wondering why you can’t do these things.

PS If I you have a different experience then please let me know via the comments and I’ll correct or add to the post