Novos projetos: FastChat e Semaphore.js

Sempre curti micro-projetos úteis e reutilizáveis, principalmente widgets.

Bom, para o projeto que estou trabalhando vi a necessidade de dois widgets que imaginei que seria legal de reutilizar, e eis o resultado deles (ainda em desenvolvimento):

Semaphore.js

Um mini widget em javascript que apenas indica o status do servidor através de um semáforo.

Através de um url configurada do widget ele indica se o servidor está online, lento ou offline. É bem útil para aplicações totalmente em ajax, principalmente quando se depende de servidores instáveis ou serviços de terceiros. Permite ainda algumas integrações para cada estado.

Consiste apenas em um pequeno arquivo javascript.

FastChat

Fastchat: chat widget easy to use

Esse é mais legal! É um widget de bate-papo que basta carregar um pequeno javascript sem dependências e está pronto o chat!

Foi feito com um servidor em clojure, usando redis e javascript simples para o widget. Pode-se usar css para customizar a UI padrão, grava um histórico, possui uma “janela” por usuário, lista de onlines e etc.

Bom, é isso, o semaphore.js eu já usei em mais de um projeto e o fastchat ainda está em teste no projeto principal, mas acho que promete bastante.

Naive Crawler in Clojure

Algum tempo atrás praticando clojure tentei fazer um crawler de web bem simples e sem dependências, apenas para testar alguns recursos. O resultado foi um programa em clojure capaz de navegar nos links a partir de uma página e salvar os conteúdos.

Resolvi acertar uns detalhes e colocar no github o naive-crawler.

O desenvolvimento foi bem incremental, primeiro as funções para lidar com links:

  • make-url recebe uma url atual e um link achado para definir o destino.
  • find-links acha links através de regex, bem falho na verdade.
  • find-urls combina as duas anterior já retornando as urls para serem navegadas .
  • same-domain? checa se o destino é do mesmo domínio da página atual.

Depois persistência:

  • make-db cria um banco de dados.
  • insert insere uma referencia a uma url no db, se ainda não existir.
  • get-it retorna o conteúdo da url salva no db.
  • non-crawled filtra as urls ainda sem conteúdo.
  • set-content salva o conteúdo no db.

Crawler em si:

  • save-page busca o conteúdo da pagina atual, salva-o e captura as urls dessa página.
  • start/-main iniciam o loop do crawler

O desenvolvimento foi bem incremental, no começo apenas fazia url a url, depois adicionei o “same-domain”, controle de erro bem básico, paralelismo simples (testei outras formas também) e depois salvar em disco.

Interessante seria salvar as URLs numa fila (PerssitenQueue? Redis?) e outras threads consumirem essa fila e salvar o conteúdo em um banco de dados (sqlite? neo4j?). E também não tem testes, pois fui fazendo tudo no REPL e esqueci de escrever os testes.

Como construir projetos Clojure com Leiningen

Dois pontos essenciais, não diretamente relacionados ao código, em projetos sérios são gestão de código (ou controle e versionamento de código) e ferramentas de automação de build. Para uma tecnologia tão prática como clojure não faz sentido usar tecnologia arcaicas e duras, então para versão de código você vai usar o GIT.

Para quem trabalha com java provavelmente está acostumado a usar o Ant ou o Maven para gerir os projetos (provavelmente parcialmente disfarçados por uma IDE), e quem já editou um pom.xml de um projeto sabe o inferno que isso se torna. Então, como uma ferramente elegante que é o Clojure, uma ferramenta de build e automação tão elegante quanto é necessária. Eis que temos o Leininghen.

Leininghen (não sei pronunciar) é uma ferramente de build para clojure em clojure desenhada para não te perturbar (adaptação minha da explicação oficial). Não tem XML, hail that. Você tem um arquivo de configuração escrito em, vejam só, Clojure! E é bem simples até (e programável, já que é de fato um programa), e pequeno.

Ele serve basicamente para:

  • Criar um projeto em branco com uma estrutura padrão
  • Baixar as depend&eecirc;ncias
  • Rodar os testes
  • Compilar e empacotar

Ele usa ainda o Clojars.org , um repositório de bibliotecas jar para clojure, como base para dependências, além de visar o GIT.

Mão na massa:

Primeiro você entra na github do leiningen e baixa o script, e coloque-o no seu path e rode o instalador:

$ wget -O lein http://github.com/technomancy/leiningen/raw/stable/bin/lein
$ chmod +x lein
$ sudo mv lein /usr/bin/lein
$ lein self-install

Isso vai baixar o próprio lein para seu usuário pode usar. Agora começamos um projeto.

lein new meuprojeto  

Isso vai criar um projeto “meuprojeto” mínimo, com a estrutura básica de pastas. Mais ou menos assim:

/meuprojeto
/meuprojeto/classes
/meuprojeto/lib
/meuprojeto/src/meuprojeto/core.clj
/meuprojeto/test/meuprojeto/core.clj
/meuprojeto/project.clj
/meuprojeto/README
/meuprojeto/.gitignore

Ele vem com as pastas para as classes compiladas, para as dependências, código fonte e testes (e o primeiro arquivo).

O project.clj é a configuração, o README é para explicação do projeto (e para o GIT) e o .gitignore também. Então agora temos que configurar o project.clj. Ele vem assim:

(defproject meuprojeto "1.0.0-SNAPSHOT"
:description "FIXME: write"
:dependencies [[org.clojure/clojure "1.1.0"]
[org.clojure/clojure-contrib "1.1.0"]])

Podemos editá-lo para tornar nosso projeto mais completo.

(defproject meuprojeto "1.0.0-SNAPSHOT"
:description "Projeto de teste do lein"
:main meuprojeto.core
:url "http://www.meuprojeto.com"
:dependencies [[org.clojure/clojure "1.1.0-master-SNAPSHOT"]
[org.clojars.okkop/clojure-couchdb "0.2"]
[org.clojure/clojure-contrib "1.1.0-master-SNAPSHOT"]])

As informação de versionamento e descrição, além de organização, vão ser usados se enviar sua biblioteca ao clojars.org. O main será definido na geração do jar, e as dependências para construir tudo e os paths.

Com o project.clj pronto você pode fazer o lein instalar as dependências:

$ lein deps

Isso vai baixar os jars na pasta lib,e ele acerta o path na hora rodar.

Agora você pode programar, criar seus testes e fazer eles passarem. Conforme programando você pode rodar todos os testes ou apenas um namespace usando o lein:

$ lein test
$ lein test meuprojeto.dbclient-test

Então quando esse release estiver pronto para distribuir, o código já no repositório (você fez os commits e os pushs e etc) você pode construir os pacotes:

$ lein uberjar

Esse vai compilar as suas classes, criar um jar “clean” (sem as depend&eecirc;ncias) e um standalone, que vai conter as bibliotecas que estão prontos para distribuir e ser executado

BONUS: Se você construiu uma biblioteca e quer torná-la disponível pelo lein você pode publicá-la no clojars.org, basta se cadastrar e depois enviar o jar “clean”: 

$ lein jar
$ scp meuprojeto.jar clojars@clojars.org:

Presto!

MagicSQL: O pior framework de ORM e SQL para PHP.

Disclaimer: eu que fiz.

A muito tempo atrás, numa terra distante, um amigo me perguntou sobre Orientação a Objetos em PHP, e sobre ORM, como resposta eu fiz essa pequena biblioteca para demonstrar o básico do básico. O “framework” MagicSQL!

Sinceramente tenho vergonha dela, não era nada sério e nem tomei muitos cuidados na época com boas práticas e testes e documentação, era só para ver alguns recursos. Mas ela funciona e eu usei em alguns projetinhos(com isso ela até evolui um bocado), mas se for escolher algum ORM para PHP, faça uma escolha mais séria.

De qualquer forma estava revendo e resolvi publicar o código, “just because”. Você pode conferir o código no Repositório do MagicSQL. Vamos a uma análise chata:

Primeiro ponto: ela funciona. Como eu usei ela um pouco então o que está lá está funcionando nos casos testados(e mais alguns). Ela consegue fazer selects, updates, inserts, deletes e joins sozinha. E_STRICT.

Segundo ponto: não tem configuração. Nenhuma. Você cria a conexão no código mesmo (como se fosse PDO) e instancia o Repositório. O resto é mágica (e não confie em mágica). Ela advinha seu schema usando describe e show tables, e faz uns cálculos para adivinhar os joins (Essa é uma parte engraçada do código).

Not lazy: Cada “requisição” faz só uma query, mesmo com joins. Ou seja, mesmo quando você carrega uma lista de objetos com listas de objetos relacionados, não importa o tamanho do join, é uma query só e tudo é carregado numa tacada só e transformado em objetos. Não queira ver esse código também.

StdClass pública: ele não usa seus objetos, apenas StdClass com atributos públicos. Whatever.

PDO e ArrayObject: Toda lista e resultado são ArrayObject (na verdade MagicCollection), então $arr[0] == $arr->get(0). Sua conexão é um PDO, caso você precise.

Quase sem documentação: Acho até que tem alguns comentários quaisquer, mas não tem PHPDoc e a documentação em si é quase nula. Mas está lá no README, example.php e test.php.

Noob testing: Bom, pelo menos tem testes unitários (ou algo parecido). Na época não tinha escolhido um framework, e como foi algo bem rápido e sujo, tem só um monte de chamadas com ifs e testes para saber se tudo correu bem. Tem até um teste que ainda falha por que nunca precisei da sua implementação (ou porque perdi a implementação).

MySql e SQLite: O objetivo inicial foi o sqlite, depois o MySql porque é o que mais uso. Apesar de usar PDO o método de “discovery” do schema não é padrão.

Usem um ORM PHP de verdade, e não esse, mas o código está ai para sua diversão.

Namespaces on clojure, and compilation.

O uso de namespaces em clojure pode ser bem simples, mas pode ser bem complicado. Vou focar no simples :)

O namespace de clojure está próximo da declaração pacote/classe no java, assim o padrão é o mesmo para nomenclatura (apesar de poder variar), dessa forma o arquivo clojure em src/twitter/search.clj teria normalmente o ns (ns = namespace) twitter.search.

A declaração básica de um namespace é a através do macro “ns”:

(ns twitter.search)  

Com os arquivos definidos com seus devidos namespace, e o classpath (cp) do java configurado certo (apontando para o src/, por exemplo, você pode chamar outros arquivos clojure pelo seu ns:

(ns twitter.main
(:require twitter.search)
)

Agora você teria o ns twitter.search disponível em seu main, mas a forma mais prática é a seguir:

(ns twitter.main
(:require [twitter.search :as search)
)

Assim o conteúdo do ns twitter.search está no simbolo alias search, dessa forma para chamar a função “search-timeline” do twitter.search você faz:

(search/search-timeline "clojure")  

Outra forma útil no ns é o “use”, que traz os simbolos do outro ns para o ns atual, assim:

(ns twitter.main (:use twitter.search))
(search-timeline "clojure")

Agora podemos também compilar nossa aplicação clojure, tendo por exemplo a seguinte estrutura de arquivos:

/app
/app/src
/app/src/twitter
/app/src/twitter/main.clj
/app/src/twitter/search.clj
/app/classes
/app/libs

Considerando que seus .jars do clojure estão no libs, conforme este texto, você deve então passar a lancar o clojure com o seguinte comando (veja o novo classpath):

java -cp ./:./src/:./classes/:libs/clojure.jar:libs/clojure-contrib.jar clojure.main $1  

Agora podemos definir um método main no nosso twitter/main.clj :

(ns twitter.main
(:require [twitter.search :as search]))
(defn -main [word]
(let [tweets (search/search word)]
(println (reduce (fn [t0 t1]
(str t0 "\n"
(get t1 "at") " @" (get t1 "from") " : " (get t1 "text")
)) "Search result" tweets ))
))

E o twitter/search.clj:

(ns twitter.search
(:use clojure.contrib.json.read)
(:require [clojure.contrib.http.agent :as http ])
)

(defn search [word]
(let [json (http/string
(http/http-agent
(str "http://search.twitter.com/search.json?q=" word)) )]
(map
(fn [tweet] {"from" (get tweet "from_user")
"text" (get tweet "text")
"at" (get tweet "created_at")})
(get (read-json json) "results"))
)
)

Como pode-se ver usamos tanto o use como o require, assim como as funções mega-hyper-uteis de map e reduce para excercício.

Mais então para compilar o projeto, lance o REPL executando apenas o “./clj” e mande compilar com:

(compile 'twitter.main)  

Agora suas classes estão na pasta classes, você pode executar a aplicação rodando:

$ java -cp ./libs:./classes:./libs/clojure.jar:./libs/clojure-contrib.jar twitter.main clojure  

Assim vai rodar o -main recebendo o “clojure” como argumento. Crie agora o script de start-up e pronto.

Bonus: uma versão em um script de 30 linhas formatadas de uma busca no twitter com clojure. Basta executar o .clj.

Hello World, em Clojure, novamente.

Já escrevi um pouco sobre clojure aqui, sobre o básico de programação funcional e o básico de clojure, mas resolvi pegar do começo agora, do hello world.

Para preparar o ambiente para o clojure basta pegar as bibliotecas do clojure e do clojure-contrib:

wget http://clojure-contrib.googlecode.com/files/clojure-contrib-1.1.0.zip
wget http://clojure.googlecode.com/files/clojure-1.1.0.zip

Descompacte e pegue os jars clojure.jar e clojure-contrib.jar e coloques numa mesma pasta “libs”, agora crie um lançador simples para o clojure, com o nome de “clj” (com permissão de execução, com o seguinte conteúdo:

#!/bin/sh
java -cp .:libs/clojure.jar:libs/clojure-contrib.jar clojure.main $1

Agora basta chamar o “clj” para ter o REPL, ou passar como parâmetro o arquivo clojure à ser executado.

Agora como primeiro programa, o clássico “Hello world”. Basta criar um arquivo hello.clj com o seguinte conteúdo:

  (println "Hello World")
(defn fac "Nice factorial impl" [x] ( reduce * (range 2 (inc x))))
(println "Factorial of 4 is" (fac 4))
(def myJson "{\"hello\":\"World\"}")
(use 'clojure.contrib.json.read)
(def obj (read-json myJson))
(println (get obj "hello"))

No exemplo, linha a linha, imprimi o Hello World, criei uma função para calculo de fatorial e imprimi o fatorial de 4, criei uma string no formato do json, importei uma biblioteca de json do clojure-contrib, fiz o parse do json e exebi sua propriedade. Basta executar:

$ ./clj hello.clj  

Simples assim.

Programando fora da zona de conforto: Programação Funcional e NoSQL

Mais alguns links da série de programação funcional, e também adcionar o NoSQL a lista, banco da dados não relacionais para resolver o problema da escalabilidade.

 Divirta-se. 

Mais sobre programação funcional e clojure

No último texto tentei explicar o básico para entender um lista em programação funcional, agora vou explicar algumas das estruturas mais essenciais para um programa funcional que seja , bem, funcional.

Vamos começar pela definição de funções, no outro texto expliquei a forma mais simples:

(defn soma [ arg0 arg1 ] ( + arg0 arg1 ) )

Essa é na verdade uma forma especial para a função que cria funções:

(def soma (fn [arg0 arg1] (+ arg0 arg1))

Essa forma original permite a primeira forma de polimorfismo de clojure, por número de argumentos:

(def soma ( fn somador ; somador é um alias opcional que sera usado dentro da funcao
 ( [arg0 arg1 ] (+ arg0 arg1))
 ( [arg0 arg1 arg2] ( somador arg0 (somador arg1 arg2))
))

Algo muito importante em programação funcional é a recursão, usada comumente no lugar de loops tradicionais, que é otimizada por recursos de tail recursion, apesar dessa otimização não ser presente no clojure, a recursividade é essencial, e a forma é com a expressão “recur”:

(defn gimme5 [ x ] 
 ( if (= x 5) 
 x
 ( recur ( + x 1))
))

Veja que vai chamar recur até que x seja igual a 5.

Uma outra forma de implementar funções também muito importante, por ter uma maior capacidade de polimorfismo é com a definição de métodos:

(defmulti hello class)
(defmethod hello String [s] (println “String: “ s))
(defmethod hello Integer [i] (println “Integer:” i))

Mais é possível muito mais que isso, pode mudar a quantidade e tipos de argumentos entre outros.

Uma construção muito importante também é o “let”, ele permite criar um ou mais símbolos e torna-los disponíveis em uma lista, veja:

(let [ x 1 y 2] ( + x y ))
(def hello [name] ( let [ intro “Hello “] (str intro name))
(def n5 (let [ x 1 sum (fn [x y] ( + x y)] (sum 4 x)))

Outra forma importante é a “do”, que executa uma série de funções:

(defn hello [s] (
 let [intro “hello ”]
 do (println “will print hello”) (println intro s) (str intro s)
)); retorna sempre a ultima instrução String de intro + s

Programação Funcional: Lendo listas e funções

Entender Programação Funcional é uma tarefa bem complicada no começo, por ser uma mudança extremamente radical na forma de pensar e de programar.

Na minha opinião temos dois pontos fundamentais a considerar: Listas e Funções. Exceto por modificadores de leitura, tudo ou é um ou é outro, e depende de ambos. Claro que há muito mais, mas acho esse o básico para ao menos “Ler” algo funcional.

Uma Lista não é um Array( ou Vetor) como estamos acostumados, mas uma série encadeada de símbolos(que podem ser ou não outra lista ou função). Para construir a seguinte lista : "Maça, Banana, Laranja" é entendida em idiomas LISP assim: (Maçã Banana Laranja).

Para entender um lista encadeada, podemos ter algo assim: (Maçã ("Banana nanica" "Banana D'Água") Laranja). É uma lista de 3 elementos, sendo que o segundo elemento é uma lista de dois elementos, mas se for assim (Maçã (Banana nanica Banana D'Água) laranja) o segundo elemento tem 4 elementos.

O processamento de Listas (LISP é isso) é feito da seguinte forma, supondo a lista:

(somar 1 2 (dividir 6 3))

O primeiro elemento de uma lista é esperado uma função, os elementos seguintes serão seus parâmetros, então temos a função "somar" recebendo os parâmetros inteiros 1 e 2, e como terceiro parâmetro vai receber o resultado do processamento da lista (dividir 6 3), que vai ser processada como uma chamada a função "dividir" recebendo 6 e 3 como parâmetros, o resultado volta como terceiro parâmetro a somar.

Como podemos ter quase qualquer coisa como símbolos, essa linha é implementada assim:

(+ 1 2 (/ 6 3))

"+" é um simbolo comum, que contem(aponta, na verdade) uma função capaz de somar que receber n argumentos, assim como "/" contem a função de divisão. Toda Lista é processada dessa forma, função + argumentos, apesar de termos modificadores (como # ou ') que alteram esse comportamento. Um array por exemplo é feito dessa forma: [ x y z ], logo não é um lista.

Agora chegamos nas funções, são exatamente como as funções matemáticas. Em LISP se define uma função usando a função especial “defun”, aqui vou usar o idioma de Clojure para demonstrar isto. Em clojure temos:

(defn funcao [x] ( processa x ) )

E o que isso quer dizer? Chamo a função “defn” e passo como argumentos o simbolo “funcao”, o array [x] e a lista ( processa x). “defn” vai ligar ao simbolo de escopo local “funcao” uma função que recebe um argumento ([x]) que será ligado a variável “x” do escopo interno da função, e que vai retornar o resultado da lista (processa x).

Como defn é uma função especial, (processa x) não é processado imediatamente, e sim, apenas quando a função for chamada. Assim quando eu chamo (funcao 3) esta lista vai retornar o resultado de (processa 3). Em um exemplo mais prático, temos:

(defn hello [name] ( println “Hello ” name) )
(hello “Diogo”) ; imprime “Hello Diogo”
(hello “Você”) ; imprime “Hello Você”

Este poderia ser implementado assim:

( (fn [name] (println “Hello ” name)) “Diogo” )

Definindo a função na hora, e passando o argumento. Então por exemplo podemos encadear chamadas:

(defn hello-maker [name] (str “Hello ” name)) ; retorna (str “Hello “ name), str constroi a String
(defn speaker [toSpeak] (println toSpeak))
(speaker (hello-maker “Diogo”))  
(defn quick-speak [speaker maker name] ( speaker (maker name))) ; são simbolo, e dentro de um escopo
(quick-speak speaker maker “diogo”)

Lembrando que por padrão somente o primeiro item é interpretado como função, a estrutura acima funciona. Agora um exemplo mais legal, fatorial, formatado:

(defn fac [x] (
  if (= x 1)
  x
  (* x (fac (- x 1)))
  )
)

Aqui temos uma séries de funções, a função ligada ao simbolo “=” recebe dois argumentos e retorna verdadeiro (booleano mesmo) se forem, quem diria, iguais. A função “if” (também é especial) recebe tres argumentos: Um boleano, uma lista(ou simbolo) para retornar em caso verdadeiro e uma para retorna caso falso. Ambas não são processadas até que if seja resolvido.

Então ao chamar (fac 5) temos x = 5, se a função “=” resolver que x e 1 são iguais, fac vai retorna x, se não vai retornar uma lista (* x (fac (- x 1))).

Então temos para retorna a função “*” que recebe x e (fac (- x 1)), processando temos fac recebendo (- x 1), que é a função “-” rebendo x e 1 , e vai retornar(surpresa) x – 1 , então retorna fac 4 (que vai ser 4 vezes factorial de 3), e por ai vai.

No caso do (fac 5) temos, no final:

(* 5 (* 4 (* 3 (* 2 1))))
(* 5 (* 4 (* 3 (2))))
até
120

Então:

(defn fac [x] ( if (= x 1) x (* x (fac (- x 1)))))
(println (fac 5)) ; imprime 120

Como disse, isso é o básico do básico, programação funcional é algo bem complexo e há muito a se aprender ainda, mas é divertido e vale a pena. Ainda bem que não sou professor, por me perdi completamente explicando ;)

Configurando o ambiente para o Clojure!

É hora da programação funcional, vou registrar aqui os passos para deixar o ambiente pronto para aprender Clojure, no Linux e com o VIM, por que eu sei que qualquer hora dessas vou precisar repetir esses passos.

Primeiro, pegue uma cópia do Clojure , coloque em alguma pasta.

Depois, você vai precisar do JLine, no linux ele esta nos repositórios da maioria das distros, então no debian:
# aptitude install libjline-java

Sequindo na brincadeira, prepare uma pasta para deixar os arquivos para rodar o clojure, no meu caso uso o /opt/clojure:

# mkdir /opt/clojure
# cp clojure*.jar /opt/clojure
# mv /opt/clojure/clojure*.jar /opt/clojure/clojure.jar
# cp /usr/share/java/jline*.jar /opt/clojure
# mv /opt/clojure/jline*.jar /opt/clojure/jline.jar
# touch /opt/clojure/clojure
# chmod 755 /opt/clojure/*
# ln -s /opt/clojure/clojure /usr/bin/clojure

Depois você também vai precisar do clojure-contrib, em um terminal compile o svn:

# svn checkout http://clojure-contrib.googlecode.com/svn/trunk/ contrib  
# cd contrib
# ant -Dclojure.jar=/opt/clojure/clojure.jar

Vamos criar então um lançador rápido para o clojure, tanto para o REPL e para o Script, no arquivo /opt/clojure/clojure fique com o seguinte conteúdo:

#!/bin/bash
THE_DIR=/opt/clojure
if [ -z "$1" ]; then
  java -cp $THE_DIR/jline.jar:$THE_DIR/clojure.jar:$THE_DIR/clojure-contrib.jar jline.ConsoleRunner clojure.lang.Repl
else
  java -cp $THE_DIR/clojure.jar:$THE_DIR/clojure-contrib.jar clojure.lang.Script $1 — $*

Agora basta usar a interface REPL através do console com o comando "clojure" ou passar um script através de "clojure script.clj".

Agora é a vez do VIM, através deste plugin do vim para o Clojure. Primeiro baixe a versão mais recente. Coloque no seu .vimrc as sequintes opções:

syntax on
filetype plugin ident on
let clj_hightlight_builtins  = 1 
let clj_hightlight_contrib = 1 
let clj_parens_rainbow = 1
let clj_want_gorilla = 1
let vimclojure#NailgunClient = "/opt/clojure/ng/ng"

E na pasta que descompactou o vimclojure, crie o arquivo loca.properties, com o seguinte conteúdo

clojure.jar=/opt/clojure/clojure.jar
clojure-contrib.jar=/opt/clojure/clojure-contrib.jar
nailgun-client=ng
vimdir=~/.vim/plugins

Sendo a linha do vimdir o equilivante do seu diretório, rode os comandos então

$ ant
$ ant install 

Passe para root e copie o vimclojure.jar para o /opt/clojure:

# cp build/vimclojure.jar /opt/clojure/vimclojure.jar
# mkdir /opt/clojure/ng
# cp * /opt/clojure/ng -Rf

Depois crie um arquivo para lançar o servidor nailgun, ao qual o vim vai se conectar, em /opt/clojure/ng-server: 

#!/bin/sh
THE_DIR=/opt/clojure
java -cp $THE_DIR/clojure.jar:$THE_DIR/clojure-contrib.jar:$THE_DIR/vimclojure.jar com.martiansoftware.nailgun.NGServer 127.0.0.1

E o ambiente esta pronto. Agora é aprender a usar ;)