Clojure on Heroku

Here's a quick link to my simple "Clojure on Heroku example" Git repository .


To quote the readme:

"A very (very) simple example of Clojure + Compojure project that can run on Heroku's Cedar stack"

A simple Clojure web app

I thought I'd start with a simple example showing why I'm coming to love Clojure. This is a small web app that accepts a GET request with an id, hits a CouchDB database, executes some simple business logic then returns the results as json.
What's interesting is that it does all this without using business objects, mappers, etc.

Clojure allows you to deserialize the json response from Couch into a hash-map and access the elements of that hash-map via symbols like so (client :address), no need for strings or accessing by a numerical index. As you can see this allows you to access values in the hash-map like fields on an object.

Clojure also has a thrush (or pipe) operator -> which can be used to pass objects into methods. While this is only syntactic sugar it allows you to use functions as if they where methods. e.g:
(-> client print-name-and-address)

This approach may not meet everyone's needs but I think it's a really great way to make lightweight, easily extensible, data driven web applications.
In the following example all the code is lumped together in 1 file just for the sake simplicity. In production code you would probably want to brake functions out into separate files for those that work on json, documents & vehicles as well as the core routing logic. (Error handling has been omitted to keep the example simple)

A fresh, new, start

Hi all,

Sorry for the lack of updates but it's been a busy year.
Soon after my last F# post I landed a pretty cool job. I've since been learning Python and a bit of Ruby/Rake.

But I have to say the language I'm really psyched about this year is Clojure... It's functional, it's JVM back-end means it's portable but most of all I like the fact Clojure has made Lisp trendy in this day and age; like some ancient, elder thing rising from obscurity to take over the world.

So, as you may have guessed, my next few posts are going to be very Clojure-centric.

A* With F#

First of all please accept my apologies if you find this post and my last one rather scant on details and description.
I'm mega-busy at the moment, I'll pop back soon and try to flesh some of these posts out with detailed descriptions.

I've updated my path finding to use a generic version of the A* algorithm. This slows it down (~6 milliseconds on my box, in debug mode) but it does make for more reusable code.

My Tools module has become the home of this new algorithm and is as follows



And my Pathfinding module has shed some weight to look like so:



JD

F# Pathfinding

I've recently started to have a play around with F# and for my first non-trivial application I'm thinking of implementing a path finding algorithm as seen in games. Seeing as this is a learning exercise I'm going to try and be as "functional" as possible (trying to stay as "pure" as I can with immutable data).

First things first:
We'll need a world to 'path find' our way around. Lets start off with defining some simple utility functions. Below is my Tools module that contains functions to:

• Square ints to a float 
• Remove items from lists 
• Load ints from a file (2D arrays of numbers will serve as our tile maps, collision maps, monster & item locations, etc)

The map:
Ok we still need to describe the world we want to navigate: In our world a 0 represents an open space and a 1 represents an area we can not enter. For example a 4 unit long corridor, running left to right, would look like this:

* Wall 1 1 1 1
* Void 0 0 0 0
* Wall 1 1 1 1

Here is my level module that describes:

• Map point: an x,y location in our 2D space, plus the value of the tile at that location and a function to calculate distance from another map point
• Map: a list of map points and a function to get the neighboring tiles of any given tile

Pathfinding: Now comes the fun part. This contains the PathingNode type (that basically wraps a map location with information that the A* path-finding algorithm needs), some utility functions and the path-finding function itself.

Level 1: Now let's create a file to represent our world. Open up a text editor and and create a delimited 2D array of 0's and 1's with a definite path between 2 points. like so:

* 0; 0; 0; 0; 0;
* 0; 0; 0; 1; 0;
* 0; 0; 0; 1; 0;
* 0; 1; 1; 1; 1;
* 0; 0; 0; 0; 0;
* 1; 1; 1; 1; 0;
* 0; 0; 0; 0; 0;
* 1; 0; 1; 1; 1;
* 0; 0; 0; 0; 0;

(I've highlighted my start tile green and end tile red for reference)
...Save this text file some where on your hard drive for later.
The Results:
The code bellow shows the pathfinding in action:

F# & SDL.NET

Disclaimer:
I'm no F# expert. I've used F# at work before but only in a single project for lexing and parsing a simple domain specific language (and the bulk of that work was carried out by a colleague). So some of this code may stink, feel free to let me know about it :¬)

I got up this morning and thought: I fancy mucking around with some F#, I know I'll make a little game.
After some Googling I was left a little disappointed when I found no good, simple, tutorials. It's been about a year since I've done any F# so I'm as good as a newbie again and needed some hand-holding. Alas that wasn't going to happen.

So my first mission was to get hold of a simple input and graphics API ... Having used SDL some time ago with C++ I went hunting for a .NET wrapper and handily enough found this: link SDL.Net

Set up:
All you need to do (at least on a Windows box with Visual Studio) is download SDL.NET, run the exe, and add a reference via solution explorer.

Code:
Now, as you can see, this code is not a "game". It simply blits a background to the screen, overlays a sprite and moves him around in response to the left and right arrow keys... VERY not-a-game indeed. But it will hopefully give anyone reading this the simple first steps towards using SDL.NET with F#.
The code also uses mutable state so is not as purely functional as I would have liked.