Primeiro, eu baixei um script que a própria FreeNode.org disponibiliza para o irssi, o instalei e depois algumas dependências.

cd ~/.irssi/scripts/autorun #Se o diretório não existir, crie-o
wget http://www.freenode.net/sasl/cap_sasl.pl

Como maioria das dependências não estavam nos repositórios oficiais do Arch Linux nem do AUR, eu tive que as instalar separadamente e ai já aproveitei pra fazer um script de instalação com todas as dependências. Esse script funciona em qualquer distro. São necessários os seguintes módulos: Math::BigInt, Math::BigInt::FastCalc, Math::BigInt::GMP, Math::BigInt::Pari, Crypt::DH e Crypt::OpenSSL::BigNum.

Abra um novo arquivo e cole as linhas abaixo, será nosso script de instalação.

#!/bin/bash
 
packages=(Math-BigInt-1.89 Math-BigInt-FastCalc-0.19 Math-BigInt-GMP-1.24 Math-BigInt-Pari-1.13 Crypt-DH-0.06 Crypt-OpenSSL-Bignum-0.04)
 
mkdir /tmp/cpan-comp
cd /tmp/cpan-comp
wget http://www.cpan.org/authors/id/T/TE/TELS/math/Math-BigInt-1.89.tar.gz
wget http://www.cpan.org/authors/id/T/TE/TELS/math/Math-BigInt-FastCalc-0.19.tar.gz
wget http://www.cpan.org/authors/id/T/TE/TELS/math/Math-BigInt-GMP-1.24.tar.gz
wget http://www.cpan.org/authors/id/T/TE/TELS/math/Math-BigInt-Pari-1.13.tar.gz
wget http://www.cpan.org/authors/id/B/BT/BTROTT/Crypt-DH-0.06.tar.gz
wget http://www.cpan.org/authors/id/I/IR/IROBERTS/Crypt-OpenSSL-Bignum-0.04.tar.gz
 
for pkg in $packages; do
	tar -xzvf "$pkg.tar.gz" ;
	cd "$pkg" ;
	perl Makefile.PL ;
	make && make test && sudo make install ;
	cd .. ;
done;

OK, o garotosopa tirou toda a graça do meu script, me alertando uma coisa da qual não sabia, para instalar um módulo do perl, basta digitar:

cpan -i Math::BigInt Math::BigInt::FastCalc Math::BigInt::GMP Math::BigInt::Pari Crypt::DH Crypt::OpenSSL::Bignum

Inicie o irssi e digite:

/sasl set freenode Seu_nick Sua_Senha DH-BLOWFISH
/sasl save
/save
/quit

Agora, é só ajeitar o config do irssi.

vim ~/.irssi/config

servers = {
	{
		address = "irc.freenode.org";
		chatnet = "freenode";
		port = "7000";
		use_ssl = "yes";
		ssl_verify = "yes";
		ssl_capath = "/etc/ssl/certs";
	}
}

Entre no irssi novamente e pronto! Só usar o /connect freenode !

E ai, gostou?

Expressões Regulares

Expressão regular é uma ferramenta muito forte para o tratamento de texto. É muito utilizado para substituições ou para verificar integridade dos dados, pois, através da expressão regular, vulga regex ou re, pode-se casar padrões de texto. Por exemplo:

/^[a-zA-Z0-9]+$/
Para somente caracteres alfanuméricos.
 
/^(\d{3}\.){2}\d{3}-\d{2}$/
Validando formato de CPF.

Esse tipo de regex é simples, valida praticamente só os caracteres que compõe uma dada string. Porém, as Perl Compatible Regular Expressions (Expressões Regulares Compatíveis com Perl), também conhecidas como pcre, permitem muito mais, inclusive utilizar condicionados (if’s), porém isso é para outro post! O que vamos falar agora é de Lookahead e Lookbehind.

Lookahead

Lookahead é uma forma de casar strings que tenham ou não um determinado final. É utilizado (?⁼…) para o positivo, ou seja, que terminem com; e (?!…) para o negativo, ou seja, que não termina com.

Um exemplo simples, seria a busca, primeiramente, de Gustavo seguido por Dutra. Se existisse Gustavo ou Gustavo Outracoisa, ele não casaria. Ao contrário, o segundo exemplo somente casaria o Gustavo ou o Gustavo Outracoisa, porém não casaria o Gustavo Dutra:

/Gustavo(?= Dutra)/
/Gustavo(?! Dutra)

Vamos ver um exemplo mais funcional e complexo em python:

import re
print re.findall(r'\s?([^;]+);', 'Vim Editor; GVim Editor; Firefox Browser; Emacs Editor; Thunderbird Email;')
# output seria:
['Vim Editor', 'GVim Editor', 'Firefox Browser', 'Emacs Editor', 'Thunderbird Email']

Mas e se quisesse somente os editores da lista?

import re
print re.findall(r'\s?([^;]+ Editor);', 'Vim Editor; GVim Editor; Firefox Browser; Emacs Editor; Thunderbird Email;')
# output seria:
['Vim Editor', 'GVim Editor', 'Emacs Editor']

Mas e se eu quisesse todos MENOS os editores? É ai que entra o Lookahead, vamos pegar todos que não terminam com Editor.

import re
re.findall(r'\s?([^;]+ (?!Editor))', 'Vim Editor; GVim Editor; Firefox Browser; Emacs Editor; Thunderbird Email;')
# output seria:
['Firefox ', 'Thunderbird ']

Observem que o que casar com (?!Editor) não entra no resultado, para incluí-lo, seria necessário uma expressão regular um pouco mais complexa utilizando condicionais. Veremos isso depois!

Lookbehind

Lookbehind faz o mesmo que o lookahead, porém, como o próprio nome diz, não procura depois, mas sim antes, da string dita. (?<=…) para o positivo e (?<!…) para o negativo.

Vamos pegar um RT de um tweet do twitter.com. Como gosto de ser eclético, vou usar perl:

print "RT \@gustavotkg Testando ERs." =~ /(?< =@)gustavotkg/
# Output seria:
1

Essa expressão retorna 1 (ou seja, TRUE), caso exista algum gustavotkg precedido por uma @.

OBS: @ são escapadas porque representam variáveis do tipo array em perl.

print "Este é um RT \@gustavotkg Testando ERs." =~ /(?< !RT )\@gustavotkg/
# Output seria, vazio, pois o @gustavotkg é precedido por um RT
 
print "RT \@gustavotkg2 também estou testando ERs." =~ /(?<!^RT \@gustavotkg\b)(.+)$/
# Output seria:
RT @gustavotkg2 também estou testando ERs.

O \b significa borda de palavra (espaço, ponto final, exclamação, final de linha, etc). Como 2 não é uma borda de palavra, pois a expressão regular diz o seguinte: "Case com tudo que não começar com RT @gustavotkg seguido de uma borda de palavra".

Condicionais

Como se pode notar nos casos acima, os operadores de lookahead e lookbehind não colocam o valor casado junto ao resultado final. Para isso temos que verificar condicionalmente e adicionar manualmente o valor. A sintaxe é esta: (?(condicao)(caso verdadeiro)|(caso falso)).

Parece complicado, mas é bem simples, vamos começar com algo fácil utilizando php:

preg_match("/(?(?< =@)\w+|\w{2})/", "@testando", $r);
var_dump($r);
# Output seria:
array(1) {
  [0]=> string(8) "testando"
}
 
preg_match("/(?(?< =@)\w+|\w{2})/", "testando", $r);
var_dump($r);
# Output seria:
array(1) {
  [0]=> string(8) "te"
}

Notem o condicional: Se começar (lookbehind) com @, então quero que case toda a palavra que segue o @, caso contrário, quero apenas os dois primeiros caracteres. Fácil? Vamos complicar!

Lembra do exemplo mais acima do lookahead? Vou refrescar a memória:

import re
re.findall(r'\s?([^;]+ (?!Editor))', 'Vim Editor; GVim Editor; Firefox Browser; Emacs Editor; Thunderbird Email;')
# output seria:
['Firefox ', 'Thunderbird ']

Notem que ela não adicionar a categoria do Firefox nem do Thunderbird, pois o (?!) como supracitado, não é colocado junto no resultado final. Para adicioná-los, podemos usar o condicional.

preg_match_all("/(\w+ (?(?!Editor)\w+));/","Vim Editor; GVim Editor; Firefox Browser; Emacs Editor; Thunderbird Email;",$e);
var_dump($e);
// Output seria:
array(2) {
  [0]=>
  array(2) {
    [0]=>
    string(16) "Firefox Browser;"
    [1]=>
    string(18) "Thunderbird Email;"
  }
  [1]=>
  array(2) {
    [0]=>
    string(15) "Firefox Browser"
    [1]=>
    string(17) "Thunderbird Email"
  }
}

Ou seja, no segundo índice do array, que na verdade é o indice 1, consta o resultado pego. Veja que utilizamos o seguinte método: Se \w+ não for seguido de 'Editor' então pega o \w+, senão ignora pois não é para casar. Assim, se for Editor, ele nunca irá casar.

Dúvidas? Sugestões? Deixe um comentário!

Depois de atualizado o pacote exaile do ArchLinux, o plugin XKeys parou de funcionar e não aceitava mais minhas teclas de atalho do teclado para manipular áudio, como forward, backward, stop, play, etc.

Esse problema era antigo, ele acusava que era necessário a lib mmkeys.so e que não estava presente. Nunca tinha tempo pra verificar o problema, até que eu decidi ir atrás.

Configurando as teclas

O objetivo do post é solucionar o problema, mas para não ficar descontextualizado, vou mostrar como mapear as teclas. É fácil e biodegradável, não polui o meio ambiente.

xev | grep keycode

Vão vir linhas confusas a cada tecla pressionada. O importante é o número junto o “keycode“. Pegue o número da respectiva tecla e escreva em ~/.Xmodmap:

keycode NUMERO = XF86AudioLowerVolume
keycode NUMERO = XF86AudioMedia
keycode NUMERO = XF86AudioMute
keycode NUMERO = XF86AudioNext
keycode NUMERO = XF86AudioPlay
keycode NUMERO = XF86AudioPrev

Substitua o NUMERO pelo número do keycode que você detectou com o xev, acho que está claro o que cada um representa, né? Abra o arquivo ~/.xinitrc e adicione

xmodmap ~/.Xmodmap

Se você tiver preguiça de reiniciar a interface gráfica, pode digitar o comando acima para fazer as teclas funcionarem. Ai é só habilitar no exaile!!!

Ajustando o Exaile

pacman -Ql exaile | grep mmkeys

Identifiquei que a mmkeys.so realmente não constava nos arquivos de instalação do exaile. Como o pacman guarda um cache das versões dos programas que eu instalei e atualizei, fui verificando os arquivos de cada uma delas atrás dessa lib, pois um dia isso havia funcionado.

pacman -Qpl /var/cache/pacman/pkg/exaile-0.2.14-2.pkg.tar.gz | grep mmkeys

Esta foi a última versão que tem a dita lib (exaile /usr/lib/exaile/mmkeys.so) – aparentemente o problema veio da versão 3 em diante -, então bastou eu jogá-la para /usr/lib/exaile.

mkdir /tmp/exaile-src
tar -xzvf /var/cache/pacman/pkg/exaile-0.2.14-2.pkg.tar.gz -C /tmp/exaile-src
sudo mv /tmp/exaile-src/usr/lib/exaile/mmkeys.so /usr/lib/exaile/mmkeys.so
rm -r /tmp/exaile-src

Pronto! Não precisa nem reiniciar o exaile, apenas habilitar o plugin XKeys que ele irá reconhecer automaticamente as suas teclas de atalhos.

Não fui atrás para saber se é problema no empacotamento ou o quê, mas deve funcionar isto até sair uma outra solução.

Para mais informações http://www.tchelinux.org/2009. As palestras serão:

VIM-de a mim, produtividade

Uma palestra que mostra maneiras para um edição de texto efetiva e rápida usando o vim.

jQuery – Introdução

Apresenta o porquê do jQuery ser um excelente framework para desenvolvimento rápido com javascript.

Se alguém tiver assistido a alguma palestra, favor dar um feedback!!!

• Certeza de encontrar todas as incidências
• Ficam visualmente destacadas (com :set hlsearch)
• Testar substituições
• Verificar a ortografia atrás de erros de digitação
• Encontrar variáveis ou funções não utilizadas, só declaradas
• Encontrar rapidamente algum termo
• Verificar a existência de algum termo

Além da conhecida / (barra) para buscar, existe o :vimgrep. É dele que quero falar.

Vimgrep

Comando

:vim[grep][!] /{pattern}/[g][j] {files}

• Busca inscidências de pattern nos files listados.
• pattern pode ser uma expressão regular ou não
• A exclamação (!) ignora as alterações já feita no arquivo atual
• g procura por todas as inscidências, não só a primeira, em cada arquivo
• j pula para o primeiro resultado ao executar o comando
• files podem conter wildcards, como *, ? e **
• Os resultados são abertos na quickfix list

Exemplos

:vimgrep! /$var/ arquivo.pl

Pesquisa pela primeira inscidência de $var no arquivo.pl

:vimgrep /texto/ *.rb

Busca por texto em todos os arquivos com a extensão .rb do diretório atual (para descobrir qual o diretório atual, use :pwd. Para mudar :cd dir)

:vimgrep /TeXtO/ *.py dir/*.py

Busca com case-sensitive em todos os arquivos .py do diretório atual e dos dentro do diretório dir/.

:vimgrep /minhaFuncao/g **/*.c

Busca recursiva dentro da árvore de diretórios do diretório atual cuja extensão seja .c

:vimgrep /< \([^ ]\+\)[^>]*>.\+< \/\1>/ index.html

Busca usando expressões regulares também são permitidas!

Navegando na QuickFix List

• :copen
• :cfirst
• :cprevious
• :cnext
• :clast
• :cclose

Como nosso foco é a eficiência, podemos criar mapeamentos para andar pela quickfix list!

map <F9> :copen<CR>
map <F10> :cclose<CR>
map <A-j> :cnext<CR>
map <A-k> :cprevious<CR>

Exemplo de uso do vimgrep

Conclusão

Esse recurso não parece ser muito abordado por ai, mas é extremamente importante. Seja criativo e descubra onde melhor usar o :vimgrep! Tenho certeza de que vai lhe ajudar! E quando encontrar, comente ai!

• screen
• ssh
• vim
• skype

Destas, só o skype não é open-source. Mas é interessante manter uma conversa verbal, pois conversas escritas podem desviar o foco da programação, que é bem mais rápida e precisa do que a escrita, que pode deixar brechas para má interpretações. A conversa verbal consegue interromper o programador ao mesmo tempo em que escreve, corrigindo-o ou questionando-o.

Conectados no skype, basta decidir em qual máquina será o desenvolvimento. Esta, por sua vez, terá que ter um servidor ssh. Ela será o host da programação. Será necessário, também, nesta máquina, ter instalado o screen, que é um programa que possibilita criar ’sessões’ no terminal.

Host

screen -S PairProgramming

Parece que nada mudou, mas você está numa sessão do screen chamada PairProgramming.

Precione CTRL+a e digite:

:multiuser on

Pressione CTRL+a novamente e digite:

:acladd usuarioclient

Tudo que você ver nesta sessão, será visto pelo outro usuário (usuarioclient) que se conectará nela.

Então, abra o vim, pois será necessário um edito de textos de verdade , e se divirta:

vim /caminho/arquivo

Client

ssh usuarioclient@host
screen -x usuariohost/PairProgramming

Pronto! Agora você está acessando a mesma seção! Tudo que o usuáriohost fizer, o usuárioclient enxergará e vice-versa.

Agora, basta descutir a tarefa via Skype e programar. As atualizações são em tempo real, ou seja, aparecem ao mesmo tempo que são escritos, digo… depende da conexão, mas não é um grande problema.

Caso seja necessário que o usuarioclient não possa modificar o código, apenas assitir e dar pitacos, o usuáriohost deve pressionar CTRL+A e digitar:

:aclchg usuarioclient -w #

Eu ainda vou programar assim, depois digo a experiência.

Referências

• Linux.com
• Jason Haruska

Baseado nisso e no comentário que recebi recentemente e inspirado pelo post de um amigo, vou fazer uma lista de coisas que proponho. São coisas simples, mas que facilitam na manutenção.

Umas das coisas que aprendi com Uncle Bob (Robert C. Martin), no seu livro Clean Code foi: escrevemos o código apenas uma vez, porém o mesmo é lido várias vezes. Então, não custa usarmos 5min a mais documentando alguma coisa ou escrevendo variáveis legíveis, que nos pouparão tempo mais tarde!

1. Clareza e objetivadade nos nomes das variáveis

É incrível como as pessoas conseguem dar nomes criativos para variáveis. O alfabeto tem tantas letras que formam tantas palavras, por que insistem em usar apenas 1 letra como nome de variável? Pior, Por que usar sempre as mesmas?

$d = 3;
$dias = 2;

A primeira variável simplesmente não diz nada. Olhando ela não se consegue ter noção nenhuma do que ela representa, o que é o 3? Do mesmo modo se aplica a segunda variável, sabemos que são 2 dias, mas 2 dias não nos diz nada também. Olhando assim, só sabemos a unidade de medida!

$dia_vencimento = 3;
$qtde_dias_para_pagamento  = 2;

Há quem reclame do tamanho das variáveis. Mas hoje em dia, que editor não auto-completa para você? Se o seu não, por favor, considere trocar =).

O que se deve cuidar ao se nomear uma variável, é não por algum nome que venha a ter mais de uma possibilidade de significado. Por exemplo:

$valor_frete_desconto = 11.3;

O valor acima citado, é referente ao desconto dado ao frete, ao valor do frete a ser descontado ou o valor do frete com o desconto? Eu não afirmo nenhuma hipótese à partir do nome dado. Se me perguntarem, eu diria que olharia o código para afirmar. Por tanto, seja CLARO E OBJETIVO.

$valor_frete = 13.4;
$valor_desconto_frete = 2.3;
$valor_frete_descontado = $valor_frete - $valor_desconto_frete;

Caso o desconto do frete seja aplicado com porcentagem:

$pct_desconto_frete = 10;
$valor_frete = 13.4;
$valor_desconto_frete = $valor_frete * ($pct_desconto_frete / 100);
$valor_frete_descontado = $valor_frete - $valor_desconto_frete;

A melhor coisa em relação às variáveis é justamente o fato de omitir o valor atrás de um nome inteligível. Por tanto, sempre que possível, esconda os valores, a legibilidade aumenta muito!

    $arr_usrs = array();
    for ($i = 0; $i < count($users); $i++) {
        if ($users[$i][3] == 4)
            $arr_usrs[] = $users[$i];
    }
    return $arr_usrs;
}

Pergunto:

• $arr_usrs é uma lista gerada à partir de que dados?
• O que é o índice 3 do array usado no if ?
• O que diabos quer dizer == 4?
• O que devo esperar que $arr_usrs contenha?

define("STATUS", 3);
define("ATIVO", 4);
    $contatosAtivos = Array();
    for ($i = 0; $i < count($contatos_do_usuario); $i++) {
        $contato = $contatos_do_usuario[$i];
        $status_do_contato = $contato[STATUS];
        if ($status_do_contato == ATIVO)
            $contatosAtivos[] = $contato;
    }
    return $contatosAtivos;

Acho que não preciso explicar o código, não é?

Outra coisa interessante, CUIDADO com as variáveis de duplo sentido.

$total = count($usuariosDoBanco);

$total recebeu o total de usuários do Banco de Dados ? o total de usuários de um determinado banco (BB, Santander, etc) ?

Sugestão:

$total = count($usuarios_cadastrados);

ou, para o outro caso

$total = count($clientes_santander);

Eu sei que muitas vezes é difícil escrever códigos de forma bonita, mas o esforço vale a pena! Além de ser um diferencial profissional, trabalhar no meio da zona é prejudicial a você mesmo!

Lembrou de algo? Tens outras dicas? Comenta aê!

Quando eu vou escrever em algum programa de qualquer suíte de escritório – openoffice, koffice, etc -, eu geralmente me preocupo mais com o negrito da palavra, com identação do parágrafo do que com o conteúdo em si. Isso é um pecado.

Meu primeiro instinto foi: vou escrever tudo no Vim, depois colo no Impress. Boa! Ok, mas e quanto às páginas?
Vou ter que por página por página? Ainda sim eu teria mais trabalho. Eu teria que refazer as listas para que ficassem com as “bolinhas” à esquerda. E teria que modificar todos os títulos para negrito?

Fui pro google e achei um plugin que já conhecia no resultado: VimOutliner. Ele dita uma sintaxe muito intuitiva para hierarquisar (existe esse verbo?) o conteúdo. Algo assim:

Título do documento
 
Tópico Nível 1
	Tópico Nível 2
	: Parágrafo com alinhamento justify
	; Parágrafo fica do jeito que foi escrito
	- Item de lista
	+ Item de lista numérica

O plugin vem com documentação e um shell script que instala automaticamente o plugin. O site tem toda documentação, é bem simples.

Em http://perens.com/FreeSoftware/Outline/ é possível encontrar vários scripts que convertem o documento para outros formatos. Um deles é o vo2odp.rb, um script em ruby para converter arquivos para o OpenOffice Presentation.

Pra fazê-lo rodar, eu sofri um pouquinho. Tive que instalar o ruby (obviamente) e o rubygems. Depois de instalado:

$ gem install builder
$ gem install rubyzip

Também alterei o script, segue o patch das modificações:

29,30c29,30
< require_gem 'builder'
< require_gem 'rubyzip'
---
> require 'builder'
> require 'zip/zip'

Copie o trecho acima em um arquivo, por exemplo: /tmp/patch_vo2odp, depois execute

$ patch /caminho/para/vo2odp.rb < /tmp/patch_vo2odp

Pronto, agora só escrever sua apresentação. Lembre-se que o plugin tem uma extenção própria, a .otl. Sempre que um arquivo for aberto com esta extenção, o Vim irá carregar o syntax highlight apropriado e algumas outras opções para melhor escrever sua apresentação.

Concluída a apresentação, você pode usar

$ ruby /caminho/para/vo2odp.rb apresentacao.otl apresentacao.odp

Abra com o OpenOffice e salve como .ppt. Pronto! Você acabou de fazer sua apresentação no PowerPoint pelo Vim.

Observações importantes

• O script não quebra as páginas dos slides automaticamente. É separado por capítulos de nível 1. Então, não escreva coisas muito longas dentro de um nível. Lembre-se que é uma apresentação e não um documento de texto.
• Quando aberto no OpenOffice, use o negrito, sublinhado, coloque imagens, etc. Crie seu layout e não pense nisso durante a criação do conteúdo. Escreva antes e formate depois

E isso ai! Gostou? Não? Comente! Dê dicas e sugestões!

Parece radical, mas a produtividade aumenta, de certo modo. Não só na hora de programar e testar, sempre que edito arquivos no Vim, tento não usar o mouse. Claro que sempre vai ter alguma aplicação que vai te obrigar a usar o mouse, mas se pudermos evitar, melhor!

Eu continuo com esta idéia. Coisinha bonita é para cliente final. Desenvolvedores devem trabalhar com ferramentas que proporcionam o melhor uso do tempo possível, pois o bom profissional é aquele que esbanja do ócio, eis o fluxo:

• Concluir as atividades rapidamente com eficácia e eficiência está diretamente ligado ao ócio, pois se ele tivesse feito algo mal feito, estaria corrigindo os bugs e não vendo vídeos no youtube.
• Com tempo livre, o cérebro humano fica mais descansado e mais propício a receber insights/intuições para resolver problemas difíceis, que – e estes merecem – precisam de mais tempo e necessitam ser bem planejados.
• Resolvendo problemas de forma criativa – talvez até inovadora -, faz com que se evite problemas futuros. Logo, se poupa tempo. Se poupando tempo, voltamos a cláusula anterior.

Parece utópico, mas eu acredito nisso. Eu acho que é possível. Basta saber onde conseguir ganhar tempo em atividades, automatizando com scripts, programas e etc, o tempo é consequência.

Todo Desenvolvedor Web já foi ou ainda é DBA. É inevitável aprender a utilizar banco de dados sem modelar os dados. Geralmente, para isso, é utilizado alguma ferramente gráfica que auxilia na visão do modelo. Não vou citar, mas existem várias para isso.

Porém, há um detalhe que muitos não se atinaram ainda. Me dei conta disso assistindo uma palestra no FISL10, na palestra do Leandro Dutra (se for parente, é primo de muitos graus :S) chamada O elefante ilustrado: modelagem literária e documentação automática em PostgreSQL e outros SGBDs livres.

SchemaSpy

O que é?

É uma ferramente que varre um banco de dados e gera um documentação em HTML nevegável. Ela gera gráfico de chaves estrangeiras utilizando o GraphViz (.dot), como se fosse uma dessas ferramentas que terminam com Designer.

Esses gráficos gerados, são visivelmente bonitos e dispostos. Ou seja, não é mais necessário sofrer arrastando caixinhas de modo com que fique bem arrumado. O programa tem um bom algoritmo para organizar. O que possibilita que o DBA, ou o desenvolvedor mesmo, use este tempo para repensar uma constraint, uma foreign key, etc.

O HTML gerado também tem abas que diferenciam os conteúdos: abas para relacionamentos, abas para tabelas auxiliares, abas para listagem de colunas/tabelas, etc. Mostra os campos, o tipo dos campos, os comentários, valores em comum e as CONSTRAINTS. Ou seja, uma solução completa para documentação de bancos de dados e modelos de ER. Vem junto o jQuery, que da uns efeitos e toggleia algumas colunas das tabelas de exibição.

Onde conseguir?

O site oficial deles é http://schemaspy.sourceforge.net. Pode ser baixado de lá. Apenas o driver jdbc para o banco de dados que for ser usado deve ser encontrado separadamente.

Quem usa ArchLinux, pode baixar os repositórios do AUR. Eu mesmo sou o mantenedor do pacote, então, qualquer dúvida ou problema, comente lá que tentarei responder/resolver o mais rápido possível. O link do repositório é http://aur.archlinux.org/packages.php?ID=28022

Como usar?

Para usar é muito simples. Depois de baixar o .jar, apenas execute

$ java -jar /path/to/schemaSpy.jar --help

Ou, se você instalou o do repositório do ArchLinux, basta usar:

$ schemaspy --help

Ele vai listar os parâmetros, é bem simples. Não vou me deter a isso. Qualquer dúvida comente no post abaixo.

Um exemplo de output pode ser encontrado na própria página do SchemaSpy: http://schemaspy.sourceforge.net/sample/

Sugestoẽs

Se existe algum defeito nele, com certeza é o template. O HTML gerado não é o mais bonito. Não obstante, me parece que o template não é customizável, para isso seria necessário hackear a classe que gera o template. Mas, quem sabe não é implementado algo nas próximas versões? Quem sabe VOCÊ não implementa?

Mas bem, falando em sugestões, aqui vai algumas:

• Integrar com a documentação do phpDocumentor, javaDoc ou outro similar.
• Versionar a documentação gerada para avaliação de crescimento da aplicação: poder comparar como era há certo tempo atrás e como está hoje.
• Programar os SQL’s utilizando algum editor de texto, fazendo você ganhar desempenho e analisar mais facilmente para comentários, constraints, triggers, procedures e views, que são geralmente mais complexas de serem vistas em programas gráficos.

Mais alguma sugestão? Críticas? Deixem nos posts abaixo!

E aquela palavra que você sempre escreve errada? Aquela função que você sempre esquece o nome?

Conheça algumas dicas para aumentar a produtividade e diminuir o trabalho dessas coisas rotineiras.

Lista de Abreviaturas

Sabe aquelas palavras que a gente insiste em escrever errado? Principalmente quem trabalha com e-mails, códigos e comentários em outras línguas tem dificuldades com certas palavras. Por exemplo,

vc -> você
q -> que
pq -> porque
nao -> não

Agora a pergunta que não quer calar: Porque não usarmos algo para evitar esse tipo de coisa? Às vezes nem notamos os erros, mas eles estão lá. Mantenha uma lista de abreviaturas no Vim. Cuide dela, adicione novas abreviaturas assim que vierem à sua cabeça. A sintaxe é simples, basta adicionar no seu .vimrc:

"" abbr ERRADO CORRETO, por exemplo:
abbr pq porque
abbr vc você

O Vim ainda possibilita que você crie sintaxes diferentes para arquivos diferentes. Então, seus arquivos .txt podem ter abreviaturas diferentes das de .py. Ou seja, se o nome daquela função python é muito longa ou você insiste em escrevê-la errada, ela merece uma abreviatura, no formato descrito acima (abbr ERRADO CORRETO).

$ mkdir -p ~/.vim/abreviaturas/
$ vim ~/.vim/abreviaturas/txt.vim

Adicione ao txt.vim as abreviaturas utilizadas para arquivos texto. Mesmo que poucas, coloque algumas. Um pouco de disciplina fará com que sua produtividade aumente. Tenha certeza.

Ao seu .vimrc, basta acrescentar:

autocmd BufNewFile,BufRead * source $HOME/.vim/abreviaturas/para_qualquer_linguagem.vim
autocmd BufNewFile,BufRead *.txt source $HOME/.vim/abreviaturas/txt.vim
autocmd BufNewFile,BufRead *.py source $HOME/.vim/abreviaturas/python.vim

O autocmd funciona mais ou menos igual a uma trigger. É um sistema de eventos, basicamente. Ou seja, ao abrir um arquivo novo (BufNewFile) ou um arquivo já existente (BufRead), se o nome do arquivo casar com a expressão (no caso, *, *.txt ou *.py) irá executar o código a seguir.

Vou falar mais sobre o autocmd em outro post, tem muitoooo pano pra manga, hehehe.

Templates de Arquivos

Quando se fala em programação é meio que como na arte. Não só porque programar é uma arte, mas porque nada se cria, tudo se copia. Tudo bem que, hoje em dia, com técnicas de encapsulamento, oop, etc, fica mais difícil. Mas sempre há coisas em comum entre os arquivos. Vamos começar com algo simples.

Template básico para javascript, onde será utilizado jquery.

$(document).onready(function(){
// code here
});

Simples, mas não é um saco ter que escrever isso sempre que abre um arquivo novo? Tome isso como regra: Faça uma, porém apenas uma vez. Não seria mais fácil abrir o arquivo e tcha-ram! Lá está o código que, em 90% dos casos, você irá utilizar?

Esse foi pequeninho, mas imagine um arquivo html. A trabalheira que é copiar todo o caçalho. E se você segue um padrão, pode usar inclusive o css junto. Observe:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

< !DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="pt" lang="pt-br" dir="ltr">
	<head>
		<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
		<meta http-equiv="Content-Style-Type" content="text/css" />
		<meta name="keywords" content="aqui,vai,as,keywords" />
		<link rel="stylesheet" href="/style.css" />
		<link rel="shortcut icon" href="/favicon.ico" />
        </head>
        <body>
        <div id="wrapper">
                <div id="head"></div>
                <div id="content"></div>
                <div id="footer"></div>
        </div>
</body></html>

E o css:

1
2
3
4
5
6
7
8
9
10
11
12

html * {
}
body {
}
#wrapper {
}
        #wrapper #head {
        }
        #wrapper #content {
        }
        #wrapper #footer {
        }

Imagine um designers, aqueles que fazem o psd e depois passam pra xhtml, tendo que copiar isso vezes e vezes para todos os arquivos que ele faz. Faça apenas uma vez e siga o padrão!

Usuários de django, ao criar um model, precisam escrever sempre os imports ? Se são utilizados sempre, porque não criar um template?

Agora você me pergunta, como carregar o template automagicamente no Vim ? Fácil! Utilizando nosso autocmd =). Do mesmo modo que fizemos com as abreviaturas, vamos criar os diretórios:

$ mkdir -p ~/.vim/templates/

Criei lá os arquivos com os templates que você acha útil.

autocmd BufNewFile *.html 0r ~/.vim/templates/html.tpl
autocmd BufNewFile style.css 0r ~/.vim/templates/cssstyle.tpl
autocmd BufNewFile jquery.*.js 0r ~/.vim/templates/jqueryjs.tpl

Agora, abra seu Vim e sinta a magia:

vim index.html style.css jquery.initscript.js

Executando comandos externos

g(un)zip

O manual do Vim tem um exemplo bem interessante, para abrir arquivos gzipados, editá-los, como se nada tivesse acontecido e salvá-lo no formato gzip de novo. Apesar de que aqui, não precisou acrescentar os códigos abaixo, ele já fez automático. Basta adicionar o .vimrc

augroup gzip
  autocmd!
  autocmd BufReadPre,FileReadPre	*.gz set bin
  autocmd BufReadPost,FileReadPost	*.gz '[,']!gunzip
  autocmd BufReadPost,FileReadPost	*.gz set nobin
  autocmd BufReadPost,FileReadPost	*.gz execute ":doautocmd BufReadPost " . expand("%:r")
  autocmd BufWritePost,FileWritePost	*.gz !mv <afile> </afile><afile>:r
  autocmd BufWritePost,FileWritePost	*.gz !gzip </afile><afile>:r
 
  autocmd FileAppendPre		*.gz !gunzip </afile><afile>
  autocmd FileAppendPre		*.gz !mv </afile><afile>:r </afile><afile>
  autocmd FileAppendPost		*.gz !mv </afile><afile> </afile><afile>:r
  autocmd FileAppendPost		*.gz !gzip </afile><afile>:r
augroup END
</afile>

Verificação por erro

Já deve ter acontecido com você: você salva o arquivo e quando vai testar, faltou um ponto e vírgula, ou escrever o nome de uma função errada, ou algo similar… um erro bobo, mas que não deixou seu código ser executado e exige reparo.

Para ajudar contra esse trabalho desnecessário (teste + correção + teste), que pode se repetir inúmeras vezes, você pode usar o autocmd para alertá-lo, utilizando ferramentas externas. Por exemplo:

autocmd BufWritePost *.pl !perl -c %
autocmd BufWritePost *.php !php -l %
autocmd BufWritePost *.java !javac -Xlint %

Use a criativdade

Utilize sua criatividade e seja mais produtivo na SUA rotina. Deixe as coisas serem automatizadas. Para mais eventos do autocmd, :help autocmd. Tem uma lista bem extensa. Leia a documentação e seja feliz =). Crítias, sugestões e CASES são bem vindos nos comentários =)