I’m extremely happy to let everyone know my book, Clojure Reactive Programming, has finally been published!

You can get it at the publisher’s website or on Amazon. I had a great time writing it and I truly hope you find it useful!

I’ve met a few authors here and there and I heard more than once that a book is never really finished. I now know what they mean.

The book doesn’t cover everything I wanted to write about due to time and space limitations. Having said that, now that the book is out I do plan to expand on a few things using this blog.

A bit late for a EuroClojure 2014 post but I suppose “better late than never” applies here.

The best part of every conference is the networking. Meeting new and interesting people is priceless and I did plenty of that - mostly over Polish beer and food. Polish beer isn’t the greatest but if you must have it, better stick to Żywiec. It’s widely available and was the one which didn’t give me a headache :) - I’ve been told there are amazing microbreweries though I didn’t get a chance to try any while in Krákow.

I’ve been learning Scala for my current client project and I find writing to be a great tool to test my understanding of any given topic. This means there might be a few Scala posts coming up soon as I keep learning interesting things.

Today I’ll be exploring a few different ways in which you can compose programs. I’ll be using Scalaz in this post.

The examples that follow all deal with Vehicles - more specifically makes and parts:

I’m sitting in the Lobby of the Hilton in Boston and since my flight back to Australia isn’t for a few hours I thought I’d write my experience report while everything is still fresh in my mind.

CUFP - Commercial Users of Functional Programming - is a Workshop-like conference targeting the practically-minded functional programming community.

As it’s stated on their website, “The CUFP workshop is a place where people can see how others are using functional programming to solve real world problems […]”.

This post is part of a series about Chris Okasaki’s Purely Functional Data Structures. You can see all posts in the series by visiting the functional-data-structures category in this blog.

Recently I had some free time to come back to Purely Functional Data Structures and implement a new data structure: Red-black trees.

Red-black trees

Red-black trees are a type of self-balancing binary search tree. Back when I first learned the balancing algorithm used in operations such as insert and delete, I remember it being a particularly tricky one.

I hinted at LambdaJam Australia back in my 2012 Highlights post and the dates are fast approaching so I thought appropriate to blog about it once more.

YOW! LambdaJam is a conference targeted at intermediate and advanced functional programmers and is organised in talks, jams and workshops.

• Talks are the traditional format and are 30 minutes long;
• Workshops aim to introduce a specific subjects to attendees in great detail and are up to two hours long;
• Jams are hands-on sessions. Participants will be guided through pre-defined problems around a given subject/technology and encouraged to work through the solutions either by themselves or ideally as small groups. Jams are also 2 hours long;

Sounds pretty amazing, doesn’t it?

Last week while attending Clojure/West in Portland I came across a paper called Why calculating is better than scheming. In a nutshell, this paper is a critique to Abelson and Sussman’s classic textbook SICP - Structure and Interpretation of Computer Programs, used by MIT for many years to teach their introductory programming course.

If you haven’t read SICP, you should. It’s an amazing book. It uses Scheme, a dialect of Lisp, as the vehicle to present fundamental programming concepts.

This post is part of a series about Chris Okasaki’s Purely Functional Data Structures. You can see all posts in the series by visiting the functional-data-structures category in this blog.

Last year I started reading a book called Purely Functional Data Structures. It’s a fascinating book and if you’ve ever wondered how Clojure’s persistent data structures work, it’s mandatory reading.

However, all code samples in the book are written in ML - with Haskell versions in the end of the book. This means I got stuck in Chapter 3, where the ML snippets start.

Today I’m releasing bouncer, which was extracted from a project I’ve been working on.

It’s a validation library for Clojure apps and it lets you write code like this:

(def person {:name "Leo"})

(validate person
    :name required
    :age  [required number])

If you’d like to see more examples and a detailed guide check out the github repository. The README should get you started.

This post however isn’t only about announcing bouncer. It’s also about the motivation and implementation details behind it.

This is Part IV of my Monads tutorial. Make sure you read the previous parts:

• Part I - Functors

• Part II - Applicative Functors

• Part III - Monoids

• Part IV - Monads (this post)

A quick recap

In Part I we learned about Functors, which are things that can be mapped over using a normal function - fmap is used for that.

Part II tought us that when our Functors themselves contain functions and we want them applied to the values contained in other Functors, Applicatives come to the rescue - and bring theirs friends pure and <*>.

This is Part III of my Monads tutorial. Make sure you read the previous parts:

• Part I - Functors

• Part II - Applicative Functors

• Part III - Monoids (this post)

• Part IV - Monads

Monoids

Simply put, Monoids describe types containing a binary function and an identity value.

When applied to the identity value and a random value x, said function leaves its argument x untouched, returning it as a result.

This is Part II of my Monads tutorial. Make sure you read the previous parts:

• Part I - Functors

• Part II - Applicative Functors (this post)

• Part III - Monoids

• Part IV - Monads

Applicative Functors

In Part I I talked a little about Haskell type signatures and introduced Functors, which provide a way to map standard functions over values which are wrapped inside a Functor - we used fmap for that. You might want to skim through it again as a refresher.

Today I join the already bloated group of people who wrote monad tutorials. It’s a bit of a ritual, really.

Different than most tutorials though I aim to take a different approach. The good news is that I won’t be comparing monads to burritos :)

People say one needs to have his/her own epiphany in order to understand Monads and reading explanations from others is of little help. My goal is to disprove that.

Recently I upgraded the clojure project I’m working on to Leiningen 2 in order to start using nrepl - since swank-clojure is now deprecated. Little did I know this would lead me to a small debugging adventure.

Heroku

I use Heroku as my deployment platform and my project had been running on it for a few weeks without any issues. I also use Heroku’s PostgreSQL solution.

However, by upgrading to Leiningen 2, my project started throwing some weird exceptions during deployment - it couldn’t connect to my database any longer. Everything was fine on my local environment though.

Last night I attended the Adobe User Group here in Sydney. That might strike some of you as a big surprise given my relationship with Adobe is pretty much limited to fiddling with Photoshop/Lightroom to get my photos looking nice.

However the reason for which I attended the meetup is that Sean Corfield - a prolific member of the Clojure community - gave a presentation on how he introduced and migrated most of his backend code at World Singles from CFML to Clojure - hence my interest.