Along with the release of Go 1.1 an official announcement went out today from the organizers of the first-ever GopherCon, a convention in Denver Colorado for those who work with, play with, and love Go. I know I’ll be there and I look forward to seeing a lot of great talks. More information can be found at GopherCon or by following @GopherCon on Twitter!

So the conclusion?

Slim for Clojure wins out for me by a wide margin. Slim is similar to Haml in its syntax, white space sensitive and generally easy to read, while adding a few nice features and eliminating a few more characters from your HTML generation.

What does it look like? A little like this:

div
  ul
    li
      p Hello World

The Clojure implementation of Slim is developed by Chas Lemley, a Ruby software developer in the Atlanta area.

*Disclaimer: I have worked with both Andy Stone, the creator of Slim and Chas Lemley. Some bias may apply.

Sounds simple, and really it was very simple, once I found a random Google Groups post talking about it.

First thing is first, add this line to your view

(:require [noir.request :as request])

Then access the body within your defpage with the following code:

(let [request (request/ring-request)
body (slurp(:body request))]
(println body)
)

And there you go. The quick, easy, no noise to fight through explanation of how to get the entire post body in WebNoir.

#1 WordPress-like Clojure CMS

This project would be massive and I’d need to build up a strong community around it, but the idea is to take clj-blog and integrate it with more of a full-purpose-cms. This project would probably be based in Noir, use Korma and generally stick to the things I’ve already decided I’m comfortable with.

#2 Clojure migrations

This one should be pretty obvious to anyone used to the ActiveRecord style migrations. There is something to say about having all of that in a runnable little script.

#3 A generator library for Noir

Noir adopts a sinatra-style “Do what you feel like doing” attitude for the structure. I’ve been thinking about rolling up a lein plugin that would generate more opinionated Noir projects (probably including Korma by default, setting up an MVC style structure and integrating the Clojure Migrations project mentioned above). This is another big project, and one that would really use Noir as a base for a much more complex framework. I’m torn on this because while it IS nice to have everything in one place, rails has been getting far too opinionated lately.

#4 An implementation of Slim and/or Haml 

The Haml implemntations are hopelessly out dated (many not seeing updates over the last two or three years) and as far as I know no port of Slim has been done. This might be a cool project to improve an otherwise painful templating situation in Clojure.

And that’s all she wrote:

Let me know if anything there seems stupid, useful or otherwise worth commenting on. More importantly let me know if any of that exists and I just failed at researching it!

I’m embarking on a new personal project which requires a pure offline environment, something I haven’t done in any form in years and realistically have never done. Even in my past working with C# applications they always connected to remote databases maintained on networks and relied heavily on server storage. So for me, this will be my first time working on a stand alone desktop application.

Of course the Clojure comes in because I want to build something cross platform, targeting Mac OSx and Windows XP – 8…okay maybe not 8. I’m not sure yet.

At any rate if you’re not familiar with QT you should be. It’s a cross-platform UI framework maintained/developed by Nokia available through an LGPL license, making it a legitimate choice for commercial and open source uses.

Getting everything installed:

 Now because Clojure is a JVM based language you can count on using the Java libraries to hook QT into Clojure. Let’s go ahead and assume that you’ve installed Clojure 1.4.0 through HomeBrew, because that’s what I did.

Now you’re going to want to download the QT Jambi library, this is the java implementation of QT. Simply unzip the package

To run the sample binary to view some of what QT Jambi can do simply terminal to your new qt jambi folder and run the following commands.

chmod +x qtjambi.sh

sudo ./qtjambi.sh

Note: You may need to open qtjambi.sh and add ”-d32″ to the java command being called near the end of the file, this will force it to run in 32-bit mode, which is required for Lion/Mountain Lion

Now what I did was install qtjambi into my local maven repository using the following command:

 mvn install:install-file -Dfile=qtjambi-4.7.0.jar -DartifactId=qtjambi -Dversion=4.7.0 -DgroupId=qtjambi -Dpackaging=jar

But there are other ways to get your dependencies loaded, I just have a preference for my local maven repo.

Writing your hello world:

So, of course, we’re going to do the old stand-by HelloWorld app.

The first thing we’re going to do is create a new project in lein by doing a simple lein new hello_world.

Add :main hello_world.core to your project.clj in your new application.

Go ahead and define main in your core.clj file, it should look something like this:

(ns hello_world.core)

(defn -main [] (println “Hello World”))

Now on to the GUI!

We didn’t come here to print stinkin’ lines! Still, if everything runs with lein run from the console then we should be good to go. Let’s start doing some GUI work.

Now what we don’t have is the .* notation on an import, so we won’t get to import the entirety of QT, what’s more we have to make two more modifications to project.clj.

The first thing to do is add the following line to your project.clj inside your dependencies:

[qtjambi "4.7.0"]

add this line beneath your :main statement:

  :jvm-opts ["-d32" "-XstartOnFirstThread"]

This will tell Lein to run in 32bit mode and tell QT where to start, both are important to keep it from crashing.

Now in core add these lines directly below your Namespace declaration.

(import ‘com.trolltech.qt.gui.QApplication
‘com.trolltech.qt.gui.QPushButton)

Okay, time to wrap it up by modifying your (main) so that it looks like this:

(QApplication/initialize (into-array [""]))
(.show (new QPushButton “Hello World”))
(QApplication/exec)

When you do Lein Run now you should see a very small window with a very informative button on it, one that says Hello World! Congratulations, you’ve taken your first steps into the world of GUI applications with QT and Clojure, and for that matter so have I.

We’ll see where this takes us.

The full source for the sample project can be found at https://github.com/mblake/jambi-hello-world.

Enjoy!

I’m honestly starting to wonder if I shouldn’t take the time to learn WordPress theming.

Oh well, back to work!

For the most part it’s a very simple task thanks to form helpers in Hiccup (the HTML rendered that Noir houses underneath) that allow us to build what we need in much the same way we would with Ruby.

A basic example of a user registration form looks like this:

(defpartial register []
(html5
(form-to [:post "/save_user"]
(label “username” “Username:”)
[:br]
(text-field “username”)
[:br]
(label “password” “Password:”)
[:br]
(password-field “password”)
[:br]
(label “email” “Email”)
[:br]
(text-field “email”)
[:br]
(submit-button “Add user”)
)))

Now there are a few things there that might bear a little explanation.

html5 tells Hiccup what to expect when rendering. There’s no real trick there and everything is taken care of by the library.

form-to takes the path to the action you’re going to post the form data to. Just like in rails this is going to be a defined route somewhere in your app. It will look like this:

(defpage [:post "/save_user"] {:as user}
(user/save_user user)
(resp/redirect “/configure”))

What I’m doing here is defining an accessible page (save_user) that defines a PersistentArrayMap (the format our data comes to us) as variable user. I then go off and save that user in a model and call resp/redirect from the library noir.response.

That was easy-peasy, and we have a form that submits our user’s input and does it all in 100% genuine Clojure.

Author’s Note: The more time I spend in Clojure, the less I think about where my parens go and how to format my code. If it looks scary now, give it a chance. It has a way of growing on you.

To use Incanter just include it in your project.clj (you are using lein, right) using:

[incanter "1.3.0"]

Then run lein deps in your console to install the dependency.

After that all you need to do to retrieve an excel file is use the following code.

(use ‘(incanter core io excel))

(defn get_excel (read-xls “/My/File/Location.xlsx”))

There you are. You now have the content of your excel file in a readable, manipulable list that you can use any way you please. This is both an easier and more pleasant experience than what I’ve seen with Excel documents in ruby, especially when you need to open both xls and xlsx documents.

This distraction is almost entirely based on my recent experience with Korma, the SQL DSL-of-choice for Clojure.

Korma itself is a great library, and I’m a huge fan. It’s solid dependable and well thought out, well, mostly. And there’s where my problem occurred.

My days are spent working with Oracle and SqlServer. Two technologies that are, by most measures, just unpleasant. They’re good at what they do and where they do it, but the level of standards compliance they support is about nil. So while working with Clojure and Korma I tried to do a limit on a query. You know the old “Select * from my_table LIMIT 20″.

One minor problem though, in Oracle it’s “Select * from my_table WHERE rownum <= 20″. Korma doesn’t place nice with this (admittedly annoying) way of doing things.

Now you might expect this will turn into a rant about making sure that all supported toolchains are FULLY supported, and it very well COULD turn into that, but this time it won’t. Why? Because Korma is open source, and Korma is freely available to fork, patch, modify and use in just about any way you like.

So what does this have to do with public consumption? I wanted to point out all the things Korma does right and where many other libraries could learn. First of all it IS open source, so it’s easy to get to and to modify that’s great but even great FOSS libraries can be hard to change. Where Korma succeeds is in two places.

#1

Readable code. Not only is Korma’s code is to read but it is logically organized and split into reasonable, easy to locate functions. Korma proves that even a relatively complex library can be built in a way that is easily consumed by a Clojure noob like myself.

#2

TESTS! I can not stress this enough. If you push out a library to the public and it’s untested you should be publicly shamed, your face should adorn piñatas and small children should mock your beard.

In short:

I’m finally writing to say something positive, and to remind anyone looking to write libraries I might need to use some day to keep them clean. Once you turn your code loose to the community we will be watching, and we will be judging.