Tis the season to write Clojure
Tags: beginners, clojure, christmas
Published: 2018-12-01 09:49:06

---
title: Tis the season to write Clojure
published: true
description: Discover the simplicity of clojure while writing a Secret Santa program
tags: beginner, clojure, christmas
---

`[:fa (take 9 (repeat :la))]`

This post is aimed at beginners who want to take a look at *Clojure*, a super-interesting language which is probably quite different to what you’re used to. 

You will learn some basic concepts and see how to write a Secret Santa assigner because _IT’S CHRISTMAS_!!!!! :D

## Assumptions
- You are somewhat familiar with programming, understand concepts like flow control (`if`, `when`, `for`, etc), variables, functions, & methods. If you’ve done a bit of Ruby or Javascript, you’ll probably be fine.
- Everything you do for this post will be done through the terminal, so it’s assumed you have some familiarity and confidence with it.

## What is Clojure?
- A general purpose language like Java, Ruby, et al
- Can also compile to Javascript so you can use Clojure to write client-side code for your website as well as the backend; so you can write a rich website end-to-end with one language

## Getting started

[Here’s a link to install a tool called Leiningen](https://leiningen.org/#install) which lets you easily create Clojure projects. 

If you’re on a Mac and have `homebrew` installed you can just run `brew install leiningen`. If you dont have homebrew installed, [you should install it](https://brew.sh/) as most useful coding tools are installed using it.

Check your installation is working by typing `lein` in your command line, you should see a load of blurb.

_The first time you run `lein`it may take some download the stuff it needs. It won’t be that slow on subsequence runs._

#### If you see it complaining about JDK
Clojure is compiled using the Java Development Kit which you might not have installed on your computer. On Mac you can use `brew` to install it.

`brew update && brew cask install java`

Assuming it’s all working you can now type `lein repl`, this is a great way just to experiment with Clojure as you can just type code and try it out.

The last line in the terminal should read something like `user =>`. If you ever wish to quit the REPL just type `exit` and hit return.

Type `(println "Hello, world")` and hit return and you should see

    Hello, world
    nil

### What’s with the nil?

Every time you execute some Clojure like `(println "hello world")` it _will always return a value_. They are called “expressions”. This is a strength of Clojure and adds to its simplicity via consistency. 

Think about some functions you have called in other programming languages, sometimes they return a value and sometimes they don’t. 

Given this Javascript

    function myAdder(x, y) {
    	 x + y
    }


Oops no result! You forgot to put `return`.

This approach results in Clojure being more terse, you don’t have to worry about explicitly returning, imagine how rubbish this would be:

`(return + 20 (return - 50 20))`

In the case of `println` it can’t return anything meaningful as it just prints to the screen so it returns `nil` which means “nothing”. The REPL always prints the result of the expression you run, so in the last case you see our `println` being printed, and then the result of the expression being printed (`nil`).

If you try `(+ 20 50)` you will see it just prints `=> 70`.

### REPL tips

- Inside the REPL if you’re not sure what a function does type `(doc function-name)` e.g `(doc println)`
- Often you can use tab to get auto-complete¡
- Press the up arrow key to cycle through previous expressions

### Clojure vs Javascript

Here’s some examples of some common operations you’d do while writing an application in both Clojure and Javascript. Try out the Clojure examples in the REPL and get in the habit of using `doc`

Note the variety of syntax for doing these tasks in Javascript compared to Clojure. 

This isn’t picking on Javascript in particular, this is true of most mainstream programming languages.

#### Adding

Javascript: `1 + 1`

Clojure `(+ 1 1)`

#### Calling a function

Javascript `alert('Chris')`

Clojure `(println "Chris")`

#### Flow control

Javascript

    if(CHRISTMAS){
    	return “PUT NUTMEG IN EVERYTHING”
    } else {
    	return “PUT SORROW IN EVERYTHING”`
    }
    
Clojure

`(if :CHRISTMAS "PUT NUTMEG IN EVERYTHING" "PUT SORROW IN EVERYTHING")`

#### Doing stuff with lists

Javascript 
`["chris","ruth"].foreach(name => println('hello' + name)`

Clojure 
`(doseq [name ["chris" "ruth"]] (println name))`

## How is Clojure different?

You should notice that the syntax for all of this stuff is the same

`(function argument1 argument2)`

And you can build more complicated expressions, just like you do in maths by nesting.

`(+ 20 (- 30 50))`

The inner expression gets evaluated leaving us with

`(+ 20 -20)`

Which is `0`.

In JavaScript and most other mainstream languages arguments and function names can appear in different orders and positions, you also need to know symbols like `return` and `=>`. It’s no wonder learning programming is so difficult.

What I find the most interesting thing about Clojure is that the syntax is completely uniform. The barrier to entry to learning _how_ to write valid Clojure is very low. Writing _Clojure that actually works_ is still a challenge just like any other language, but the syntax is very easy to pick up.

An interesting side-effect of this approach is that you will come to understand that `the code in clojure is data`. When you are constructing functions like `(+ 2 2)` that is actually a _list_ of data, containing functions and arguments (just like a list of names like `("chris" "ruth")`). 

Accomplished clojure-ists use this to write _code that parses and manipulates code_ called “macros”. Try not to worry too hard about this right now, but it is a very interesting property of Clojure.

## Secret Santa time

Now you probably feel like a Clojure expert so lets ship some epic code.

### Values

When you write code you generally need to store useful information in variables for later use. To do that in Clojure, there is no magic special syntax (as promised!) just call `def`.

In the REPL try `(def my-santas ["Chris" "Ruth" "Turner" "Hooch"])`.

The only new syntax you’ve seen here is `[ ]` which creates a data structure called a `Vector` which for now you can just think of as an Array like in Ruby or JS. 

If you want to get to your variable, just type `my-santas` into the REPL. 

### How do you Secret Santa?

We need some kind of algorithm to pair up people for Secret Santa. When thinking about this stuff it’s often helpful to think about how would you solve the problem in real life. 

- We need a way of representing in data people being paired up; `x gives to y, y gives to z`
- We need to randomise the people

How _I_ have done this is just one of many ways of doing Secret Santa. I fully encourage you to try different ways!

When tackling a problem you’re not sure about it’s always best to break the problem down into smaller and simpler chunks. 

#### Representing our data

For a starting point, we need a way of representing our pairing up of Santas. The `map` data type is perfect for this. If you’re unfamiliar, a map is a data structure like an Array but it has a set of keys with corresponding values. 

They are called HashMaps in Ruby and Objects in Javascript. You can broadly think of them as dictionaries. 

We can represent our result for Secret Santa in a map (syntax for maps are `{key1 value1, key2 value2}`)

`{"chris" "ruth", "ruth" "hooch", "hooch" "turner", "turner" "chris"}`

i.e Chris gives to Ruth, Ruth gives to Hooch, etc.. 

#### Creating our first representation

`zipmap` is a function in Clojure that takes two vectors and “zips” them into a map (funnily enough). 

So try in the REPL `(zipmap my-santas my-santas)` 

You should get `{"Chris" "Chris", "Ruth" "Ruth", "Turner" "Turner", "Hooch" "Hooch"}`

OK, so everyone is just giving a gift to themselves but our basic data structure is there and we can see if we can just adjust the second argument to `zip-map` in such a way that everyone is moved along one, it could work! 

Try experimenting with `zipmap`, what do you think happens with `(zipmap my-santas [1 2])` ?

#### Rotate the list

We don’t want Ruth give a gift to Ruth, if we can take our second copy of `my-santas` and change it then everyone will give to someone different 

Imagine our room of Santas standing in a line
`Chris Ruth Turner Hooch`

Then you clone them (like our `zipmap` does)

`Chris Ruth Turner Hooch`

`Chris Ruth Turner Hooch`

If we just shifted the cloned row to the right, and put the person on the end back to the beginning…

`Chris Ruth Turner Hooch`

`Hooch Chris Ruth Turner`

Everyone could take their gift and give it to the person in front of them and we would have our Secret Santas.

How do we do that?

Again, try and simplify the problem

- Make a new vector
- With the last one as the first item
- Then the rest on the end

Clojure’s amazing standard lib again provides us with `last` to get the last element of a vector and `butlast` to get everything _apart_ from the last item. Along with the function `cons` which lets us create new vectors let’s stick it all together.

In the spirit of breaking things down first try `(cons (last my-santas) (butlast my-santas))`

Then put it together

`(zipmap my-santas (cons (last my-santas) (butlast my-santas)))`

You’re allowed newlines to let the code breathe a bit

    (zipmap my-santas 
    		 (cons (last my-santas) (butlast my-santas)))

Which results in `{"Chris" "Hooch", "Ruth" "Chris", "Turner" "Ruth", "Hooch" "Turner"}`

Awesome! Chris gives to Hooch, Ruth gives to Chris, etc. 

#### Randomise
This is nice but it gives us the same result every time. We can make our algorithm even better by adding some randomisation.

##### Shuffle 
Try typing `(shuffle my-santas)` in the REPL and you’ll see it takes a `Vector` and shuffles it. This could be useful for us to make our expression a bit more exciting.

##### Let
`let` is a function that allows you to declare values that can be used inside the function passed to it

`(let [x 1, y 2] (+ x y)`

_(Remember this might look a bit weird but it still follows the convention of `(fn arg1 arg2)`. It's just for `let` its 1st argument is a vector, and then an expression to run)_

In Javascript it’s:

    x = 1
    y = 2
    return x + y

The utility is the same, when writing non-trivial code you need to capture values and name them to improve readability. Coming back to our case we want to create a variable called `random-santas` that stores our shuffled Santas for the rest of the code to use.

##### Stick it all together
Let's use these functions to make our algorithm less predictable and store some values to let our code read easier.

    (let [random-santas (shuffle my-santas)
       shuffled-santas (cons (last random-santas) (butlast random-santas))]
       (zipmap random-santas shuffled-santas))

The code now reads relatively ok!

- Randomise the santas list
- Create a copy of that list called `shufled-santas`, where everyone has moved to the right and we put the last Santa at the front
- zip them together to create our pairings of `Chris gives to Ruth`

## Challenge for yourself

What if you want to re-use our amazing algorithm with different sets of Santas? 

You probably want to define a function, so you can use it just like we’ve used functions like `shuffle` and `zipmap`.

The basic syntax for defining your own function is

`(defn name-of-function [arg1, arg2, etc] function-body)`

### Example

`(defn add-2 [number] (+ number 2))`

And then you can call it just like any other function `(add-2 10)`

Give it a go! Write `secret-santa`.

## We saved Christmas!

That was probably a lot to take in but I hope it has been at least interesting. Maybe try to re-implement it yourself and see how far you get. Can you think of different ways to write it?

What might be more interesting is to implement the Secret Santa in a language you’re more familiar with. Think about how different your implementation is to the Clojure one, especially in regards to potentially all the different kinds of syntax you faced vs `(fun arg1 arg2)`.

[This was originally posted on my blog](http://www.quii.co.uk)