• Part 1: Project Setup
• Part 2: Data model definition with Lobos and Korma
• Part 3: Loading Fixures with clj-yaml and HTML Templating with Enlive

Introduction

In the previous part of this tutorial we created a couple of tables using migrations – users table and posts table. In this part first I’ll describe how to load some test data (a.k.a ‘fixtures‘) into our database tables. We’ll use YAML to define a couple of users and 3 blog posts and we’ll parse the YAML file and load the data using the clj-yaml library.

Also we’ll create our first template and render the blog’s home page with the sample data from the database.

Source code on github

The code for this series is now available on github and the source code is tagged with part names. If you want to checkout the code for a specific part of this tutorial you can do so using the following command:

git clone git://github.com/vijaykiran/clog.git
cd clog
git checkout part3

A quick note for PostgreSQL users

In the previous while creating the tables using migrations, I overlooked and made a mistake in naming the tables. If you are using PostgreSQL then the word “user” is a reserved word, so you should rename the table to users – I’ve updated the code accordingly.

Loading Fixtures

Fixtures are used to populate the database with some initial data. Though fixtures are mostly used for loading test data we can also use fixtures to bootstrap the content. First let us create a file called fixtures.yml under resources folder. If you don’t have a resources folder in your project, create it under the root directory so that will be at the same level as src folder.

Edit the fixtures.yml and add the following:

authors:
    - id: 1
      username:     "john"
      password:     "clojure-blogger"
      email:        "john@clojure-blog.org"
    - id: 2
      username:     "jane"
      password:     "clojure-blogher"
      email:        "jane@clojure-blog.org"
 
posts:
    - title: "Hello World!"
      text: "<em>Welcome to Clog, the World's most advanced Clojure Blog Engine!</em>"
      status: true
      author: 1
    - title: "Hello World!, again!"
      text: "Sayin 't 'gain! <em>Welcome to Clog, the World's most advanced Clojure Blog Engine!</em>"
      status: true
      author: 2

Now, fire up the Clojure REPL in IntelliJ IDE using Tools -> Start Clojure Console. We’ll load the clj-yaml library and parse the yaml file.

;; load clj-yaml
(use 'clj-yaml.core)
(parse-string (slurp "./resources/fixtures.yml"))

If everything went well, you should see the map with keys :authors and :posts in the console as shown below:

{:authors 
  ({:id 1, :username "john", :password "clojure-blogger", :email "john@clojure-blog.org"} 
   {:id 2, :username "jane", :password "clojure-blogher", :email "jane@clojure-blog.org"}), 
 :posts 
  ({:title "Hello World!", 
    :text "<i>Welcome to Clog, the World's most advanced Clojure Blog Engine!</i>", 
    :status true, :author 1} 
   {:title "Hello World!, again!", 
     :text "Sayin 't 'gain! <i>Welcome to Clog, the World's most advanced Clojure Blog Engine!</i>", 
    :status true, :author 2})}

Now to add the authors to the database all you need is the following couple of lines:

;;load korma library and models
(use 'korma.db 'korma.core 'clog.models)
(insert authors (values (:users (parse-string (slurp "./resources/fixtures.yml")))))

The second line in the above code snippet reads the fixtures file using slurp, parses the yaml using parse-string which returns a map with keys :users and :posts. We use clojure’s maps-as-functions-of-keys features to get the list of users and pass them to Korma’s insert function. Once this is executed you can see the data is now inserted into the Users table.

(select authors)
;;output
[{:id 1, :username "john", :password "clojure-blogger", :email "john@clojure-blog.org"} 
 {:id 2, :username "jane", :password "clojure-blogher", :email "jane@clojure-blog.org"}]
(select posts)
....

Templates using Enlive

Now that we have our sample data populated in the database, it is time to get started with our first template. Clojure has a couple of libraries that can help you with dealing with HTML viz, Hiccup and Enlive. Hiccup is a DSL for generating HTML and Enlive is a selector based templating engine. I’m a bit biased towards Enlive – since I have more freedom of styling and HTML stays HTML. So in this tutorial I’m using Enlive.

Defining Home Page Template

Enlive provides a macro called deftemplate to define template functions. The macro is defined as follows:

(defmacro deftemplate
 "Defines a template as a function that returns a seq of strings." 
 [name source args & forms] 
  `(def ~name (template ~source ~args ~@forms)))

The forms you pass in are actually used to transform the html. I think it will be easier to understand with an example that you can follow along. First let us create the home.html under resources folder. By convention the templates are loaded from the resources directory.

<!DOCTYPE html>
<html>
<head>
    <title>Title Here</title>
</head>
<body>
Clog - Home Page!
</body>
</html>

We will place all our template definitions in clog.templates namespace which lives in cleverly named templates.clj

(ns clog.templates
  (:use [net.cgrand.enlive-html]))
 
(deftemplate home-page "home.html" []
  [:title] (content "Clog - the clojure blog engine!"))

In the above snippet we are using deftemplate macro to create a template function called home-page which takes the file home.html and transforms the file using the forms, in our case only one which is:

[:title] (content "Clog - the clojure blog engine!")

This says find out the tag :title in the home.html and replace its contents with “Clog – the clojure blog engine!”. To test this out you can load the namespace in repl and run the home-page function. That will print out the transformed template as shown below.

(use 'clog.templates)
nil
user=> (home-page)
("<!DOCTYPE html>\n" "<html>" "\n" "<head>" "\n    " "<title>" "Clog - the clojure blog engine!" "</title>" "\n" "</head>" "\n" "<body>\nClog - Home Page!\n</body>" "\n\n\n" "</html>")

Now this template function can be used to generate the transformed html we need to send to the client. To connect the these views to the requests, we will use simple controller functions. These functions/handlers are then used to transform the templates using the request parameter and data from the database. For example we want our blog to respond to something like http://host:port/posts/1 by sending out the html for the post with id 1. This logic is wrapped inside a controller function.

A simple Controller

We’ll put our controller functions in the clog.controller namespace. Here’s the initial version of the controller which has handler for the index page.

(ns clog.controller
  (:use clog.templates
         clog.models
         ring.util.response))
 
(defn index
  "Index page handler"
  [req]
  (->> (home-page) response)) ;; A sexier way to write (response (home-page))

Now to see this function in action, we need to update the routes of the application in core.clj to call clog.controller/index. Here’s the complete core.clj after the required modifications:

(ns clog.core
  (:use ring.adapter.jetty
        ring.middleware.resource
        ring.middleware.reload
        ring.util.response
        net.cgrand.moustache
        clog.controller))
 
;; Routes definition
(def routes
  (app
    [""] (delegate index)))
 
;;; start function for starting jetty
(defn start [port]
  (run-jetty #'routes {:port (or port 8080) :join? false}))
 
(defn -main []
  (let [port (Integer/parseInt (System/getenv "PORT"))]
    (start port)))

Start the server as shown below, and you should see the home page with title in the window title bar “Clog – the clojure blog engine!”.

(use 'clog.core)
(start 9000)

List of Posts

The home is working, but it is rather boring and doesn’t show any real data. Let us try to show the two posts we added in the database. First we need to update the home.html to create a place holder for a post.

<!DOCTYPE html>
<html>
<head>
    <title>Title Here</title>
</head>
<body>
<div class="post">
    <div class="title">Title of the Post</div>
    <div class="content">Post Content</div>
</div>
</body>
</html>

Now let us update the template and add another transformation. In this case we want to “clone” the div with class post and replace the content of divs with classes title and content. Here’s the updated deftemplate’s code that does exactly the same. We are using clone-for macro and using the forms to transform the sub elements.

(deftemplate home-page  "home.html" [posts]
  [:title] (content "Clog - the clojure blog engine!")
  [:div.post] (clone-for [post posts]
                [:div.title] (content (:title post))
                [:div.content (content (:content post))]))

Now we need to make sure that our controller function sends the required data to the template.

(ns clog.controller
  (:use  clog.templates
         clog.models
         ring.util.response
         korma.core))
 
(defn index
  "Index page handler"
  [req]
  (->> (select posts) home-page response)) ;; Equivalent to  (response (home-page (select posts))

We are selecting all the posts using Korma select function and passing it on to home-page function. The result of the home-page template function – which is the html with posts populated is passed on to response.

After making these changes, you should see the list of posts in the home page.

Conclusion

In this part we saw how to glue things together and get the content from database, render it in a page using templates. In the next part we’ll finish by updating the home template and adding another template to display the post. Also, in the next part we’ll start working in creating an admin area with authentication.

Make sure you subscribe to the RSS feed or follow me on Twitter to get notified.

1. Herman Miller Aeron: Ultimate Programmer’s Chair
2. Nerf Recon CS-6 with N-Strike Darts: For fun times.
3. 17″ Mac Book Pro with 8GB RAM, SSD running Emacs in Full Screen: Ultimate Programmer’s Computer
4. The Joy of Clojure: The book for Ultimate programming language
5. mStand for MBP: For enhanced ergonomics and coolness factor

Not shown in the photo:

• Super Awesome Colleagues
• Projects using cutting-edge tech including: Scala, Play! Framework.
• No Managers
• No Managers, Seriously.
• WORK-ON-YOUR-OWN-COOL-PROJECT-EVERY-FRIDAY – Yeah, EVERY Friday.

Like what you see and curious about what we do ? Come and talk to us at Play!ground on February 3rd at Paddy Murphy’s Irish Pub, Rotterdam.

• Part 1: Project Setup
• Part 2: Data model definition with Lobos and Korma
• Part 3: Loading Fixures with clj-yaml and HTML Templating with Enlive

Updated: 31st January, 2012 – Renamed all ‘users’ to ‘authors’ to prevent problems with PostgreSQL

Introduction

In part 1 of this series, we learnt how to setup a Clojure web application project – Clog a blogging engine. In this second part of the tutorial we will start working on the application’s database layer – setting up the schema, creating migrations and finally creating the entities for the model. This terminology should be familiar for people who already worked with other web application frameworks such as Ruby on Rails or Play! framework. If you have never used these frameworks, do not worry no knowledge of those is assumed in this tutorial.

Source code on github

The code for this series is now available on github and the source code is tagged with part names. If you want to checkout the code for a specific part of this tutorial you can do so using the following command:

git clone git://github.com/vijaykiran/clog.git
cd clog
git checkout part1

Database Schema Setup

Normally when you want to work with a database, you will create a schema using DDL (Data Definition Language). DDL contains SQL statements like “CREATE TABLE AUTHOR …” etc. This will define the schema objects you need to store your application’s data. In this post however, I’d like to show you how you can create and manage the schema using a Clojure library called Lobos.

Lobos library provides a DSL (Domain Specific Language) that helps you in defining the database schema and migrations in a Database-agnostic way. By that I mean you can define your schema in Clojure and you can use Lobos to create the schema on any database e.g. PostgreSQL, MySQL or HSQL.

Before we begin, we need to create a database. As you might have seen in part 1‘s dependency listing, for this tutorial we will use PostgreSQL as the database.

Database Setup

First install PostgreSQL for your platform by downloading it from here. Create a user with login clog and your choice of password. Create a database named clogdb and make sure that the user has permissions on the database. To perform these steps you can either use the pgAdmin GUI tool to manage the database or you can use psql command line tool. If you prefer the latter, you can use the following commands to create the database and user:

CREATE USER clog WITH PASSWORD 'Your_Choice_Of_Password';
 
CREATE DATABASE clogdb;
 
GRANT ALL PRIVILEGES ON DATABASE clogdb TO clog;

Schema Creation using Lobos

Before we start writing code in Clojure with Lobos, let us take a quick look at the terminology.

Migrations

Migrations are incremental steps that you have taken to evolve your database schema. Let me explain what a migration means with a concrete example. When you are creating the tables for our blog engine, you will create a table called Posts to store our blog posts. The Posts table might contain the following columns: id, publishedDate, status, content, title. To create a table with these fields you’ll use the following SQL DDL:

CREATE TABLE posts ( id INTEGER UNIQUE, 
                     title text NOT NULL,
                     content text,
                     published_date DATETIME NOT NULL,
                     STATUS text NOT NULL, 
                     CONSTRAINT posts_id_key PRIMARY KEY (id));

Now at a later point of time you want to add rating to all the blog posts, that means you need to alter the schema to add a new column to the Posts table. This can be done using following Alter table statement.

ALTER TABLE posts
      ADD rating INTEGER;

In the above scenario, your database schema on the whole, has two versions or revisions. Version one that resulted when you executed the CREATE table statement and Version one when you executed the Alter table version. You can treat the two statements you used to modify the database as two migrations. Initially your database schema is at Version 0, once the first migration is executed, you have updated your database to version 1. After second statement, the ALTER TABLE one, is executed your database will be at version 2.

To “rollback” the schema you need a statement which will drop the added rating column, and another to drop the table completely which will result in database resulting in Version 0. When all these SQL statements are combined we get what we call “migrations”. Migrations help you “migrate” and “rollback” the database. Think of the migrations as a version control mechanism for your database.

Now that we know what migrations mean, let us see how to create the schema and migrations using Lobos.

Schema Definition using Lobos migrations

We will define all the schema related operations and migrations in a Clojure namespace called migrations. First create a new directory called lobos under src. If you are using IntelliJ IDEA, then right click the src directory and select New > Package and create a package named lobos. Inside the src/lobos create a file called migrations.clj. Add the following code to the file:

(ns lobos.migrations
  ;; exclude some clojure built-in symbols so we can use the lobos' symbols
  (:refer-clojure :exclude [alter drop
                            bigint boolean char double float time])
  ;; use only defmigration macro from lobos
  (:use (lobos [migration :only [defmigration]]
          core
          schema)))
 
;;; Defines the database for lobos migrations
(def clogdb
  {:classname "org.postgresql.Driver"
   :subprotocol "postgresql"
   :subname "clogdb"
   :user "clog"
   :password "clog"})

The code snippet above defines a namespace migration with one var clogdb which is a map of database connection information. You may need to change the database password with the one you used while creating the database user.

We create our first migration that will add the users table:

(defmigration add-authors-table
  ;; code be executed when migrating the schema "up" using "migrate"
  (up [] (create clogdb
           (table :authors (integer :id :primary-key )
             (varchar :username 100 :unique )
             (varchar :password 100 :not-null )
             (varchar :email 255))))
  ;; Code to be executed when migrating schema "down" using "rollback"
  (down [] (drop (table :authors ))))

Next we define the migration that will create the posts table as shown below:

(defmigration add-posts-table
  (up [] (create clogdb
           (table :posts (integer :id :primary-key )
             (varchar :title 250)
             (text :content )
             (boolean :status (default false))
             (timestamp :created (default (now)))
             (timestamp :published )
             (integer :author [:refer :authors :id] :not-null))))
  (down [] (drop (table :posts ))))

The above code is pretty much similar to the authors table migration – a title column, text column and a couple of timestamp columns to store the created and published date and times. Also, every post belongs to an author, so we create a foreign key to the authors table using :refer. Here we are referring to the :authors table’s :id column.

To run the above code, start a REPL console if it isn’t already running. Type the following commands into the console:

(use 'lobos.core 'lobos.connectivity 'lobos.migration 'lobos.migrations)
(open-global clogdb)
(migrate)

You should see the following output in the console:

WARNING: alter already refers to: #'clojure.core/alter in namespace: user, being replaced by: #'lobos.core/alter
WARNING: drop already refers to: #'clojure.core/drop in namespace: user, being replaced by: #'lobos.core/drop
WARNING: complement already refers to: #'clojure.core/complement in namespace: user, being replaced by: #'lobos.migration/complement
nil
{:default-connection {:connection #, :db-spec {:subprotocol "postgresql", :classname "org.postgresql.Driver", :subname "clogdb", :user "clog", :password "clog"}}}
add-authors-table
add-posts-table
nil

To cross check what relations are created in the database, you can use psql and try the following commands:

clogdb=# \d
\d         
             List OF relations              
 Schema |       Name       | TYPE  | Owner  
--------+------------------+-------+------- 
 public | lobos_migrations | TABLE | clog   
 public | posts            | TABLE | clog   
 public | authors            | TABLE | clog   
(3 ROWS)                                    
 
clogdb=# \d authors                                                                           
\d authors                                                                                    
             TABLE "public.authors"                                                           
  COLUMN  |          TYPE          | Modifiers                                              
----------+------------------------+-----------                                             
 id       | INTEGER                | NOT NULL                                               
 username | CHARACTER VARYING(100) |                                                        
 password | CHARACTER VARYING(100) | NOT NULL                                               
 email    | CHARACTER VARYING(255) |                                                        
Indexes:                                                                                    
    "authors_primary_key_id" PRIMARY KEY, btree (id)                                          
    "authors_unique_username" UNIQUE, btree (username)                                        
Referenced BY:                                                                              
    TABLE "posts" CONSTRAINT "posts_fkey_user" FOREIGN KEY ("author") REFERENCES authors(id)    
 
clogdb=# \d posts                                                                           
\d posts                                                                                    
                  TABLE "public.posts"                                                      
  COLUMN   |            TYPE             |   Modifiers                                      
-----------+-----------------------------+---------------                                   
 id        | INTEGER                     | NOT NULL                                         
 title     | CHARACTER VARYING(250)      |                                                  
 content   | text                        |                                                  
 STATUS    | BOOLEAN                     | DEFAULT FALSE                                    
 created   | TIMESTAMP WITHOUT TIME zone | DEFAULT now()                                    
 published | TIMESTAMP WITHOUT TIME zone |                                                  
 author    | INTEGER                     | NOT NULL                                         
Indexes:                                                                                    
    "posts_primary_key_id" PRIMARY KEY, btree (id)                                          
Foreign-KEY constraints:                                                                    
    "posts_fkey_author" FOREIGN KEY ("author") REFERENCES authors(id)

Lobos keeps track of which migrations are run using the lobos_migrations table. As you can see below our current lobos_migrations contains two migrations we have written and executed.

clogdb=# SELECT * FROM lobos_migrations;  
SELECT * FROM lobos_migrations;           
      name                                
-----------------                         
 add-authors-TABLE                          
 add-posts-TABLE                          
(2 ROWS)

Entity Definition

After creating the database, now we’ll define our entities using the SQL library Korma. What is Korma ?

Korma is a domain specific language for Clojure that takes the pain out of working with your favorite RDBMS. Built for speed and designed for flexibility, Korma provides a simple and intuitive interface to your data that won’t leave a bad taste in your mouth.

Korma makes it easier to deal with the database. Instead of using SQL queries, you can use Clojure to access the database. To get the data from the tables, first we need to define entities using the Korma’s defnentity macro. First create a file called models.clj in your src/clog folder. And add the following code to the file:

(ns clog.models
  (:use korma.db
        korma.core))
 
(defdb clogdb
  {:classname "org.postgresql.Driver"
   :subprotocol "postgresql"
   :subname "clogdb"
   :user "clog"
   :password "clog"})
 
(defentity users)
(defentity posts)

The above code defines two entities authors and posts. Let me show you how we can insert an author record into the database and select the list of authors from the database. Start Clojure REPL, if it isn’t running already. Type the following code into REPL:

(use 'korma.db 'korma.core 'clog.models)
(insert  authors (values {:id 1, :username "vijay", :password "password", :email "mail AT vijaykiran.com"}) )

This will insert a new record into the database. You can use the select function to get the list of authors from the authors table.

(select authors)
[{:id 1, :username "vijay", :password "password", :email "mail AT vijaykiran.com"}]

Source Code

If you are stuck at any point and want to directly checkout the code, you can use the following commands to get the code that is tagged with part2

git clone git://github.com/vijaykiran/clog.git
cd clog
git checkout part2

Conclusion

This concludes the part 2 of this series. In this part of the tutorial we saw how to create a simple schema using Lobos library, also we defined the entities for the tables we created using the Korma library. In the next part I’ll show you how to populate sample data into the database and we’ll create our first template to display the data in the browser.

Make sure you subscribe to the RSS feed or follow me on Twitter to get notified.

If you have any feedback on this article and its content, you can contact me via Twitter.

via The Rise of the New Groupthink – NYTimes.com.

• Part 1: Project Setup
• Part 2: Data model definition with Lobos and Korma
• Part 3: Loading Fixures with clj-yaml and HTML Templating with Enlive

Introduction

Clojure is general-purpose compiled, dynamic, Lisp-dialect language that targets JVM (also .Net CLR and JavaScript). There are many ways you can build a Web application using Clojure. You can use a simple framework like Noir or you can pick and choose libraries you like and build your own web stack along the way. I assume that you already started learning Clojure using some tutorial or a good Clojure book.

In this blog post series I’ll explain how to build a web application using Clojure. Creating a blogging engine seems to be the equivalent “hello world” for Web application development, so let us build a blog engine in Clojure: Clog.

Clojure Web Application Toolkit

There are many fantastic libraries available for Clojure for any type of task you can imagine and superior Java Interoperability of Clojure gives you seamless access to innumerable Java libraries and API that you can benefit from. To build a database backed web application you might need some standard libraries to perform HTTP Routing, Database connectivity and migrations, HTML Templates etc.

We’ll use the following libraries to build our web application:

• Clojure – 1.3.0 – The language.
• ring –  1.0.1 – The HTTP Abstraction API and Middleware.
• moustache  - 1.1.0 – HTTP Routes DSL
• lobos –  1.0.0-SNAPSHOT – Database Schema Manipulation and Migrations
• korma – 0.2.1 – DSL for Database Connectivity and Interaction.
• enlive – 1.0.0 – Selector based HTML library.
• postgresql - 9.1-901.jdbc4 – PostgreSQL JDBC4 driver.
• clj-yaml – 0.3.1 – A snakeyaml wrapper for YAML file parsing and generation.

The above list is just for your information. You don’t need to individually download those libraries. For those of you who are familiar with Java dependency management tools like Apache Maven or Apache Ivy, Clojure ecosystem has similar build tool called Leineingen which helps you configure your project, manage dependencies etc.

Leiningen is for automating Clojure projects without setting your hair on fire.Working on Clojure projects with tools designed for Java can be an exercise in frustration. With Leiningen, you just write Clojure.

Using Leiningen you can configure your project settings using Clojure. Leiningen uses Apache Maven for dependency resolution. So you can add any library from a maven repository as a dependency to your Clojure project. Installing Leiningen is very straight forward, which is left as an exercise to the reader.

Project Setup

After you have installed leiningen you can create a project by typing the following command in your terminal (or command) window.

lein new clog

If leiningen is installed properly you should see an output of the command similar to the following

→ ~$ lein new clog
Created new project in: /Users/vijaykiran/clog
Look over project.clj and start coding in clog/core.clj

When you run the above command, leiningen will create a simple Clojure project named “clog” for you. If you look into the clog folder, you see there are several files and folders created. Again, if you are familiar with Apache Maven, you can see the structure is pretty similar to standard Maven project. Anyway, let us take a quick look at the generated files and folders:

• README – A simple README file
• project.clj – The Clojure project configuration file – written in Clojure.
• src – Folder for your source code
• test – Folder for your tests
• src/clog/core.clj – The “core” Clojure file for your project (You can change it to whatever you want, but for simplicity, we’ll leave it as it is).

Create a directory called resources inside the clog directory. This directory will be used to store and serve the static resources like images, CSS files etc. of our web application.

There are many configuration options available to set up your project via the project.clj file. But for now we’ll just focus on simple things like adding dependencies.

Adding Dependencies

If you open the project.clj file under your clog folder, you can already see that there are a couple of dependencies configured using defproject macro.

(defproject clog "1.0.0-SNAPSHOT"
  :description "FIXME: write description"
  :dependencies [[org.clojure/clojure "1.3.0"]])

Let us update the file to add the required libraries (as shown above). Use your favorite editor to edit the project.clj, we’ll later setup an IDE for editing our source code. While we are there, we’ll also fix the version and description of the project and set them to 0.0.1-SNAPSHOT and A Clojure Blogging Engine.

(defproject clog "0.0.1-SNAPSHOT"
  :description "Clog: A Blog engine written in Clojure"
  :dependencies [[org.clojure/clojure "1.3.0"]
                 [ring "1.0.1" ;;; Exclude the clojure, clj-stacktrace from ring dependency
                   :exclusions [org.clojure/clojure
                               clj-stacktrace]]
                 [net.cgrand/moustache "1.1.0"]
                 [lobos "1.0.0-SNAPSHOT"]
                 [korma "0.2.1"]
                 [enlive "1.0.0"]
                 [postgresql "9.1-901.jdbc4"]
                 [clj-yaml "0.3.1"]])

After you edit the project.clj, run the lein deps command to download the required dependencies. You should see output similar to this:

~/clog $ lein deps
...
Copying 32 files to /Users/vijaykiran/clog/lib

That is all you need to do to configure and setup your project. Of course, we still need to set up the database, which we will come back to at a later stage. Next step is configure a development environment a.k.a an IDE.

IDE Configuration

All major IDEs (Eclipse with Couter-ClockWise plugin, IntelliJ IDEA with La Clojure plugin and Netbeans with Enclojure plugin) have Clojure support via Plugins. Many Clojure developers seem to prefer Emacs instead of using IDEs.

Emacs with SLIME

Emacs seems to be the favorite editor of most people in Clojure community. Emacs has several “plugins” that help with editing Clojure files. Learning & using Emacs can be intimidating at first but personally I find it very rewarding experience. If you are an Emacs user you can use clojure-mode, slime, swank and paredit as your development environment. There are several tutorials available on how to configure Emacs for clojure development. I encourage you to check them out if you want to use Emacs as your “IDE”. I use Emacs with lein swank, clojure-mode and slime-connect. I configured emacs with emacs starter kit and other plugins, FWIW, this is how it looks:

IntelliJ IDEA

For this tutorial I will use IntelliJ Community Edition with La Clojure and Leiningen Plugins. After downloading the IDE make sure you install and enable the plugins.

After you have installed both plugins, select Open Project .. option in IntelliJ and choose the project.clj from clog folder. Leiningen plugin will detect the project.clj and open the clog project as an IntelliJ project as shown below.

Make sure that you add Clojure facet to the module, which will allow you start the Clojure console for the project. Also, add the clojure 1.3 library for project if you have another version of clojure installed globally. This will make sure that when you start the Clojure console, it will use the correct Clojure version.

Startup code for Jetty Server

First step in developing a web application is to startup the jetty server. We will use the ring-jetty adapter to start-up the Jetty server. Edit the core.clj file and add the following code to it:

(ns clog.core
  (:use ring.adapter.jetty
        ring.middleware.resource
        ring.util.response
        net.cgrand.moustache))
 
;;; A simple handler to show send some response to the client.
(defn index
  [req]
  (response "Welcome, to Clog - A Blog Engine written in Clojure"))
 
;; Routes definition
(def routes
  (app
    [""] index))
 
;;; start function for starting jetty
(defn start [port]
  (run-jetty #'routes {:port (or port 8080) :join? false}))

Let us take a closer look on the code we added to the core.clj. First we defined the namespace clog.core and imported the namespaces via :use. Then we defined a simple function called index that uses the ring response method to send some text as response.

We used the moustache macro app to define the routes that we want to handle. In our case, we want the route that matches the url segment with parts [""] to the function index, which is another way saying when a client sends a request with no url segments or parameters, let the function index handle it.

Next we defined a function start that will help us to start a jetty server. It takes a port parameter, if it isn’t supplied, the run-jetty function from ring-jetty adapter will start the jetty server on port 8080.

Running the program in lein REPL

You can run this program using REPL in command line. Open a terminal window, and change to the clog directory. Then type lein repl, which will start a new Clojure REPL with the class path setup to include our project’s libraries. In the REPL, first import the clog.core namespace by typing use ‘clog.core. Now you can use the start function to start jetty on your port of choice. Here’s the transcript of the commands and their results:

→ ~$ cd clog
→ clog[master]/$ lein repl
REPL started; server listening on localhost port 53791
user=> (use 'clog.core)
nil
user=> (start 8888)
2012-01-11 16:10:41.640:INFO::Logging to STDERR via org.mortbay.log.StdErrLog
#
2012-01-11 16:10:41.642:INFO::jetty-6.1.25
2012-01-11 16:10:41.654:INFO::Started SocketConnector@0.0.0.0:8888
user=>

Open a browser window and open the URL http://localhost:8888. You should see the message Welcome, to Clog – A Blog Engine written in Clojure.

Running the program in IntelliJ IDE

To run this program in IntelliJ, start the Clojure console by clicking on the Tools -> Start Clojure Console. This will start a console in your IDE with the your module’s class path. Now type (use ‘clog.core) and (start 8888) in your clojure console. You should see the output as shown below:

You can now browse to the URL: http://localhost:8888 to see the response.

Conclusion

This concludes the part 1 of this series. In part 2 I’ll show you how to create the database schema and migrations using Clojure and lobos. Make sure you subscribe to the RSS feed or follow me on Twitter to get notified.

If you have any feedback on this article and its content, you can contact me via Twitter.

• Chana : Chickpeas
• Methi :Fenugreek Leaves
• Matki : Earthen Pot
• Basmati Rice: Basmati Rice

The main ingredients

• Tomatoes – Deseeded, diced
• Red onion
• Methi Leaves
• Mint leaves
• Chana – soaked overnight and boiled
• Saffron – soaked in warm water
• Briyani Rice – washed and soaked in warm water
• Yogurt

Spices:

• Cloves
• Bay leaves
• Black Cardamom
• Cinnamon Sticks
• Green Cardamom
• Black Cumin Seeds
• Raisins
• Green Chili – Sliced vertically
• Star Anise
• Chopped Ginger and Garlic

Making the Chana “Masala”
Heat some ghee, add the spices (Cloves, Bay leaves, Black and green cardamom, cumin seeds and star anise). After a couple of minutes add chopped onions, chili, chopped ginger and garlic. Sauté for a 3-4 minutes. Add Chopped tomatoes. Once onion and tomato become soft add Chickpeas and Methi leaves. Keep stirring and keep cooking on medium heat.

After 4-5 minutes of cooking add yogurt and mix thoroughly. Reduce the heat and cook for a couple of more minutes. You don’t need to cook it all the way, since it will be put into the oven in a Matki.

Spread the chana masala as a thick layer in a Matki (Earthen Pot), and spread soaked rice on top of it as a second layer. On the rice sprinkle saffron water, a pinch of gram masala and some mint leaves. Add another layer of Chana Masala and Rice continue till you fill up the Matki.

Place the pot in the oven pre-heated to 200° Celsius – cook for 1.5 hours. Enjoy with Raita.

I’ve been hugely impressed with the Nokia Lumia 800 running Windows Phone 7.5. I’ve had an iPhone since day one, and every model since, but I really like the new path Microsoft is cutting with WP7 so I decided to give it an extended try. It’s been a bit over a week, and so far I don’t miss my iPhone at all. In fact, going back to the iPhone feels like going back in time. It’s rough around the edges in a few spots, but I think Microsoft is up to something good here. More on this in a future post after I’ve spent some more quality time with the phone/platform.

via Some great stuff Ive tried recently – 37signals.

0 vs. nothing is one of those abstract distinctions that’s almost impossible to talk about directly; you more have to do it with examples. Imagine there’s a certain math class, and in this class there’s a fiendishly difficult 100-point midterm, and imagine that neither you nor I get even one point out of 100 on this exam. Except there’s a difference: you are not in the class and didn’t even take the exam, where as I am, and did. The fact that you received 0 points on the exam is thus irrelevant — your 0 means N/A, nothing — where are my 0 is an actual zero. Or if you don’t like that one, imagine that you and I are respectively female and male, both healthy and 20—40 years of age, and we’re both at the doctor’s, and neither of us has had a menstrual period in the past ten weeks, in which case my total number of periods is nothing, whereas yours here is 0 — and significant.

- From Everything and More: A Compact History of Infinity (Great Discoveries)

… consider for a moment how many levels of abstraction are involved in math itself. In arithmetic there’s the abstraction of number; and then there’s algebra, with a variable being a further-abstracted symbol for some number(s) and a function being a precise but abstract relation between domains of variables; and then of course there’s college math’s derivatives and integrals of functions, and then integral equations involving unknown functions, and differential equations’ families of functions, and complex functions (which are functions of functions), and definite integrals calculated as the difference between two integrals; and so on up through topology and tensor analysis and complex numbers and the complex plane and complex conjugates of matrices, etc. etc., the whole enterprise becoming such a towering baklava of abstractions and abstractions of abstractions that you pretty much have to pretend that everything you’re manipulating is an actual, tangible thing or else you get so abstracted that you can’t even sharpen your pencil, much less do any math.

- From “Everything and More – A Compact History of ∞” by David Foster Wallace

##########################################################################################
#                                 Magic Date
#
# Author: Vijay Kiran<mail@vijaykiran.com>
#
# Allows conversion of natural date string to real date object.
# e.g. tomorrow, today, 2w etc.
#
#
# Implementation is shame-lessly based on MagicDate in Python. 
##########################################################################################
##                        Requirements/Specs                                            ##
##                                                                                      ##
#
# One liner - should work like OmniFocus date field
## 
#
# Details:
# • 2d, -3w, 1h, 1y1m, and so on — Relative dates and times put the date at
# a certain amount of time from right now. Negative numbers represent times in the past.
# 
# • 2 days, -3 weeks, 1 hour, 1 year 1 month, and so on — 
# You can use the full names of units too.
# 
# • yesterday, tomorrow, next thursday, last month, this friday, and so on — 
#   You can refer to relative dates using common words. 
#   “This”, “next”, and “last” have specific meanings: this friday always means 
#   the Friday in this week, next friday always means 
#   the Friday in the next week, and last friday always means 
#   the Friday in last week, regardless of what day today is. 
#   Other units work in the same way.
# 
# • september, thurs, 2019, and so on — If you enter the name of a specific time period, 
#   the date will be at its beginning. So september means September first.
# 
# • 5/23/08 10a, 9.30.09 2:00 PM, and so on — You can use the short date format as 
#   defined in your International system preferences. 
# 
# • 2w sat, 4d @ 5p, tues 6a, aug 6 tues 5p, and so on —
#    Mix the available formats however you like.
# 
# • now, 9, 14:00, tom, and so on — OmniFocus makes its best guess 
#   at things like bare numbers, times, and word fragments. 
#   If you think something might work, give it a try.
 
weekdays = ['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']
 
magicDate = (str) ->
 d = new Date
 regs = [
   # Today
   [ /^tod/i, Date ],
   # Tomorrow
   [ /^tom/i, -> d.setDate(d.getDate() + 1) ;  d ],
   # Now
   [ /^now/i, Date],
   # Yesterday
   [ /^yes/i, -> d.setDate(d.getDate() - 1) ; d ],
   [ /^(last|next|this)\s(week)/, 
     (result) ->
       switch result[1].toLowerCase()
         when "last" then d.setDate(d.getDate() - 7)
         when "this" then d.setDate(d.getDate() + 1)
         when "next" then d.setDate(d.getDate() + 7)
       d
   ],
    # <last> <this>/<next> <weekday>
    [
      /^(last|this|next)\s(\S+)/i,
      (result) ->
        rel = result[1].toLowerCase()
        weekday = result[2].toLowerCase()
        today = d.getDay()
        # Pick index + 1 because getDay is 1 = Monday, 2 = Tuesday and so on
        index = (i + 1 for item, i in weekdays when new RegExp(weekday).test(item))
 
        switch result[1].toLowerCase()
          when "last" then d.setDate(d.getDate() - (today - index + (if (index < today ) then 0 else 7)) )
          when "this" then  d.setDate(d.getDate() + index - today)
          when "next" then  d.setDate(d.getDate() + index + today - 1 )
        d
    ]
   ]
# 
 for x in regs
     re  = x[0] 
     fn  = x[1]
     if re.test str then return fn(str.match re)

And here’s how you can use it:

testStrings = [ "yes", "yesterda", "Yes", "ye", "-"
                "tod", "todd", "today", "TodaY", "-"
                "now", "nowww", "Now", "ANDNOW","-"
                "tom", "tomorrow", "Tomorrow", "to", "-"  
                "last mon", "last tuesday", "last wed", "last thurs",  "last fri", "last sat" , "LAst Sunda", "-"
                "last week", "tHIS Week", "next week", "-"
                "this mon", "this tuesday", "this weDNE", "this thursday", "THIS FRIDAY", "this sat", "this sun", "-"
                "next mon", "NExt tue", "nex wednesday", "next thursday", "Next Friday", "Next Satur", "next sun", "-"]
 
for str in testStrings
  if str is "-" 
    console.log "---------------------------------------------------"
  else
    console.log "#{str}           =     #{magicDate str}"

Here are some photos I took at the event.

Also, yesterday – the iKiva app that I built crossed 6000 Downloads! I’m working on the next version which will be an universal app that will work on both iPad and iPhone/iPod touch. And Hopefully I’ll get enough free time to complete it in the next couple of months.

In 1909, after missing his train due to an ultimately disastrous trip to the lavatory at Ahmedpur station, an embarrassed, angry young man named Okhil Chandra Sen sent an unintentionally amusing letter of complaint to the Sahibganj divisional railway office in West Bengal. The letter proved to be an important one as, according to the Railway Museum in New Delhi, the subsequent investigation into the affair by the British Raj resulted in the introduction of toilets to all trains in the country; something that had been absent since the formation of Indian Railways in 1857.

via Letters of Note: My belly is too much swelling with jackfruit.

భరించరాని దుఃఖం మనిషిని ఆవరించినప్పుడు రెండు జరుగుతాయి. వేదనగల మనిషి పిచ్చివాడయినా అవుతాడు. నిర్మలమయిన అంతఃకరణ గల వ్యక్తి ఊహించని మలుపులో ఏకోన్ముఖుడవుతాడు. అంటే, దిక్కుతోచని దశలో బలమైన దిక్కువైపు మనస్సుని మళ్ళించుకుంటాడు. అది అతని కర్మపరిపాకం. సంస్కారం. అంతకన్నా కారణం మరొకటి వుండదు. అంతులేని దుఃఖంలో తాగుబోతులయినవారూ ఉన్నారు. అద్భుతమైన కావ్యాన్ని సృష్టించినవారూ ఉన్నారు. రెంటికీ ప్రాతిపదిక వేదనే.

తన కడుపున పుట్టింది సాక్షాత్తూ విష్ణుమూర్త్తేనన్న స్పృహ తనకి ఉండరాదని కోరుకున్నాడు దశరధుడు ముందుజన్మలో. కేవలం తండ్రికి పుత్రునిమీద ఉన్న మమకారాన్ని పూర్తిగా అనుభవించాలన్నదే ఆయన లక్ష్యం. కానీ తనకు పుట్టింది భగవంతుడేనన్న జ్ఞానాన్ని కోరుకుంది కౌసల్య. అంతటి అదృష్టాన్ని మరిచిపోతే ఎలా? ఆ దివ్యానుభూతిని కోల్పోతే ఆ వరానికి విలువేముంది? అదీ ఆవిడ ఉద్దేశ్యం.

అమెరికానుంచి వచ్చే కుటుంబాల కథ – అదొక పెద్ద ప్రహసనం. ఇలాంటి ప్రయాణాలకే ప్రత్యేకించిన పెట్టెలు కొన్ని ఉంటాయి. ఒక్కొక్క పెట్టెలో ఆరేళ్ళ వయస్సుగల పిల్లలు కాలు మడత పెట్టుకోకుండా ముగ్గురు పడుకోవచ్చును. అంత విశాలంగా, అంత భారీగా ఉంటాయి. వాటిలో ఏం ఉంటాయి? అమెరికా వెర్రిని ఇండియాలో పంచటానికి కావలసినంత సామగ్రి ఉంటుంది. వాకీటాకీలు, కీచైన్లు, రీబోక్ షూలు, రంగురంగుల టైలు, ‘కిక్ మీ ఎగైన్’, ‘ఓహో నాట్ నౌ’, ‘దట్సిట్’ లాంటి రకరకాల నినాదాల బనీన్లు, సగం చిరుగులుపడ్డ జీన్ పాంటులు, చూయింగ్ గమ్ లు , ఆమెరికాల సినిమాల కేసెట్లూ, కంప్యూటర్ ఫ్లాపీలు, కెమెరా రీల్సూ, చిన్నసైజు విస్కీ సీసాలు, మార్ల్ బరో సిగరెట్టు పాకెట్లూ … మీ ఇష్టం.

వెళ్ళేటప్పుడు ఈ సూట్ కేసులనిండా ఏముంటాయి? కరక్కాయలు, తీనేసీసాలు, మొలతాళ్ళు, ఊరగయడబ్బాలు, షిర్దీ సాయిబాబా విబూదీ, పసుపు పొట్లాలు, మిరియాలు, లవంగాల పాకెట్లు, కంచిపట్టు చీరలు, ఎమ్మెస్ సుబ్బలక్ష్మి విష్ణు సహస్రనామాలు, ఇటీవల తెలుగు సినిమాల వీడియోలు, ఘంటసాల పాత పాటలు, పవిత్రమైన గంగాజలం … మీ ఇష్టం.

ఆ ఇరవై రోజుల్లో అమెరికా పైత్యాన్నంతా ఈ దేశానికి దిగుమతి చేసి, మరో మూడేళ్ళపాటు ఇండియా సంప్రదాయ సంపదని మూటగట్టుకు పట్టుకుపోతారు.

I was in a completely different world surrounded by completely different people when I heard that Steve Jobs was dead. I deeply sighed and told someone sitting near me about the news. She asked me “Who’s Steve Jobs?”. I tried to explain how valuable his contributions are to the Software/Computer industry etc. But there was a clear indifference among the people who were paying attention to what I was talking. They clearly don’t see the value and they are right.

Anyway, so far the following is the most level headed response to Jobs’s death that I’ve seen so far among the overly-empathetic media and blogs/tweets.

“I don’t want to take anything away from the guy, he was brilliant and uncompromising and wonderful, but there’s a level of adulation that goes beyond what is merited,” said Tim O’Reilly, chief executive of the tech publisher O’Reilly Media. “There will be revolutions and revolutionaries to come.”

It will be interesting to see if Jobs’s “values” will be carried forward. Of course we’ll never see an exact replica of Steve Jobs, but I’m sure there are brighter minds and leaders to come from human race.

One of the Three Nanas by Niki de Saint Phalle