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

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.

Faz muito tempo que não dou atenção a este blog, mas pretendo voltar agora, sem promessas apenas vontade.

A novidade é que migrei do joomla(já muito desatualizado que estava, mesmo para um joomla) para o wordpress, migração tranquila com um pouco de sql e todo o conteúdo estava portado, e junto com um 301 na antiga pasta está tudo ok! (eu acho…)

E para quem acompanhava: meu feed antigo está morto :/ é preciso assinar o novo, se o conteúdo ainda interessar.

Aproveitei e atualizei tudo que tinha nesse servidor, que era outro wordpress e outro joomla e uns aplicativos perdidos. Os aplicativos eu removi, ficou apenas o que era estático (documentações, uns hotsites…) e o wordpress eu atualizei.

O outro joomla que roda aqui é um problema, antigo e meio complicado de dar manutenção. Tenho que ver o que fazer com ele, não pode ficar assim.

De resto, I am back!

Em um micro projeto precisei manter uma lista de usuários online, são usuários de várias fontes em conexões não persistentes, então fiz uma solução simples em PHP e Redis.

Primeiro você precisa conhecer o Redis e te-lo rodando, o que é bem simples:

$ git clone git://github.com/antirez/redis.git
$ cd redis
$ make
$ ./src/redis-server

Com o redis funcionando vamos usar a biblioteca Predis para trabalhar com Redis em PHP, pegue uma cópia atual e prepare o Phar do projeto:

$ git clone git://github.com/nrk/predis.git
$ cd predis
$ php bin/createPhar.php
$ mv predis-*.phar seu/projeto/predis.phar

Com as dependências prontas vamos a lógica para os usuários online: Vou implementar um método “ping” em um controller qualquer, a cada ação do usuário uma chamada ao “ping” vai ocorrer.

A cada ping o nome do usuário vai ser inserido em um “set” no redis, vou ter um “set” para cada minuto, mas usando “expire” só vou manter os sets dos ultimos 5 minutos.

Para descobrir os usuários online faço “sunion” dos ultimos 5 minutos para saber quem está online. Você pode ajustar o tempo como achar mais justo para sua aplicação.

Segue o “pseudo-controller”, devidamente comentado (no projeto é meio diferente, mas a base é essa):

PS: o Predis é para PHP 5.3, o que não deve ser um problema, certo?

Entra o gitolite, que permite fácil configuração multiusuário para um repositório Git.

Eis como proceder: Primeiro copie sua chave pública para o servidor (a mesma do github, por exemplo):

$ scp ~/.ssh/id_rsa.pub user@servidor:~/

E então faça ssh para o servidor e se torne root, para seguir os seguintes passos:

# cd
# aptitude install git
# git clone git://github.com/sitaramc/gitolite gitolite-source
# cd gitolite-source
# mkdir -p /usr/local/share/gitolite/conf /usr/local/share/gitolite/hooks
# src/gl-system-install /usr/local/bin /usr/local/share/gitolite/conf /usr/local/share/gitolite/hooks
# useradd git -d /home/git -g users -m -s /bin/bash
# su - git
$ gl-setup /home/user/id_rsa.pub

Atenção: assumi que seu usuário padrão no servidor é user, se não for troque as ocorrências. Pronto assim temos o básico pronto, agora sobre operação geral.

Você pode configurar uma interface de consulta básica na web usando o próprio git, ainda no user git faça:

$ cd repositories/testing.git
$ git instaweb -d webrick -p 8081

Agora pode acessar seu servidor na porta 8081 para navegar nos projetos. Não precisamos mais estar no servidor para os próximos passos.

Então vamos criar um novo repo e adcionar usuários, da sua maquina:

$ git clone git@servidor:gitolite-admin.git
$ cd gitolite-admin

Nessa pasta edite o arquivo conf/gitollite.conf, nessa sintaxe:

repo nome-do-repositorio
  RW+ = user1 user2 user3

Sendo user1 user2 e user3 os usuários com acesso para escrita. O repositório será criado vazio e e para liberar os usuários basta copiar as chaves publicas para a pasta “keydir”, no formato “user1.pub” e etc. Agora envie as alterações.

$ git commit -a -m 'adionado repositorio nome-do-repositorio'
$ git push

Congratz, you got git!

0. Mesão
É, eu gosto de uma mesa grande, com espaço, com papel e caneta para rabiscar ideias. Espaço, espaço eu preciso de espaço! É o zero porque o meme fala sobre o ambiente virtual apenas :)

1. Opera e Firefox
Para navegação cotidiana, testes, e-mails e etc eu uso Opera. Acho o navegador muito ágil e o sincronismo de tudo desde de bookmarks até histórico e notas bem ajuda. O firefox só quando mexo com Javascript mesmo, ai entra o Firebug.

2. Rhythmbox/celular
Rhythmbox é o player de música no Ubuntu, quando não estou em casa uso o celular mesmo. Música é essencial! Do Punk ao Metal! Oh Yeah \o/

3. Git
Controle de versão é com Git sempre, e se for possível no Github.

4. VI
Meu editor de escolha, seus atalhos no teclado “rulez”.

5. Terminal
Vários utilitários, buscas em arquivos, testes e scripts sempre úteis!

6. SSH/screen/servidores e mais vi
Sempre tem um par de servidores remotos para testar as aplicações e fazer homologações também, além de brincadeiras de qualquer tipo e quando uma banda descente vem a ser necessária.

Agora convidar outros, certo? Vou chamar um pessoal variado também: O #dev companheiro de trabalho @pedromenezes, o #dev companheiro de #cparty @shdo, o designer @richardbarros (para reviver seu blog!) e o sysadmin @ebastos.

Valeu galera!

Abraços.

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.

Seven Languages in Seven Weeks – Apesar do nome sugestivo o autor declara logo no começo que você não vai aprender sete linguagens em sete semanas. É um livro para programadores com alguma experiência que querem principalmente conhecer linguagens em outros paradigmas, assim ele vai gradativamente apresentando sete linguagens que vão cada vez mais se diferenciando das mais comuns hoje em dia e apresentando o ponto forte de cada uma e o que aproveitar delas. Um dos melhores livros que já li, recomendo muito! As linaguagens são: Ruby, IO (awesome!), prolog, Scala, Erlang, Clojure e Haskell.

Web design for developers- Programadores não entendem design (no sentido de arte) então esse livro passa os conceitos básicos para pelo menos seu projeto não ser feito e ser usado. É um bom livro.

Programming Clojure – O livro mais básico de clojure, bom para quem quer começar.

Clojure in Action – O livro mais “real” de clojure, o estudo é profundo e os exemplos são bem reais e muito uteis. Trata de MySql, Hbase, redis, http (compojure, ring e hiccup), messaging com rabbitmq e distribuição de trabalhos entre maquinas, Map/reduce entre ooutros. O mais completo eu acho sobre clojure.

The Joy of Clojure – O livro mais clojure de clojure, é o que melhor entende a ideia da linguagem e como melhor aproveita-la, meu favorito nessa área.

CouchDB The Definitive Guide – Aborda tudo que deve saber para fazer uma aplicação com CouchDB. Boa leitura.

ExtJS in Action – Achei meio fraco.

Pois é, bastante clojure. Alguns ainda na prateleira para ler (sem ordem):

• Pragmatic Guide to Git
• Pragmatic Guide to Javascript
• Erlang and OTP in Action
• Programing Erlang
• EventSourcing in Action
• Real-World Functional Programing
• Secrets of the JavaScript Ninja
• Hadoop in Action
• Jquery Novice to Ninja
• Lucene in Action
• On Lisp

Realmente estou precisando ler os de Javascript.

O uso do screen é bem simples, ele cria uma sessão de shell (bash, zsh, etc…) da qual você pode se “desplugar” e voltar depois, aonde você inclusive manter múltiplas sessões e janelas.

Para iniciar uma sessão usando um apelido, basta usar o comando “screen -S nome” e para reconectar a uma sessão interrompida “screen -r -S nome”.

Os comandos para manipular o screen começam com CTRL+A, você pode se desconectar de uma sessão sem encerrá-la com “CTRL+A CTRL+D”, pode salvar o histórico usando “CTRL+A SHIFT+H”, e ao encerrar a sessão tudo vai para um log.

Dentro de uma sessão você pode iniciar outro shell usando “CTRL+A CTRL+C”, ver a lista de shells usando “CTRL+A CTRL+W”, ir para o próximo shell usando “CTRL+A CTRL+A”.

Você pode ter janelas em uma sessão como no vim/emacs. Divide a janela horizontalmente usando “CTRL+A SHIFT+S”, divida a janela verticalmente usando “CTRL+A | “ (é o caractere de “pipe”, sabe?). Você alternar entre janelas usando “CTRL+A CTRL+I”, para fechar a janela usa-se “CTRL+A SHIFT+X”. Veja que uma janela começa sem shell nenhum.

O screen permite ainda que mais de um usuário se conecte a uma sessão, para permitir que sua sessão tenha mais de um usuário você pode usar “CTRL+A :multiuser on”, e adicione um usuário usando “CTRL+A :acladd user”, agora o outro usuário pode por exemplo fazer ssh para sua maquina e entrar na sua sessão usando “screen -x user/nome_da_sessao”. Para usar o multiusuário o screen deve rodar com “setuid”.

Lembre de não sair usando “ctrl+d” ou o screen vai encerrar, de agora em diante use o “ctrl+a ctrl+d” para manter a sessão rodando.