Sem sombra de dúvidas foi uma das melhores experiências profissionais em ‘eventos’ que tive. O desafio era desenvolver uma aplicação, qualquer que seja, no prazo de 48 horas usando Rails.

Foram um total de 300 equipes cadastradas, sendo cerca de 30 brasileiras, e nós éramos uma delas: http://railsrumble.com/teams/cangaceiros

Contávamos com a participação inicial do Maurício Linhares, que não pode participar. Corremos então a procura do Azenha por indicação do Milfont. O cara mora em SP, e nós cá no Ceará, o que dificultou um pouco a comunicação, já que era basicamente via Skype e Twitcam.

Enfim, nosso projeto era desenvolver um aplicativo de indexação de livros. O usuário se cadastra e envia seus livros que tem em sua biblioteca pessoal (em formato PDF). A aplicação lê o arquivo e o indexa, pronto para ser buscado tanto pelos dados de cadastro como pelo conteúdo. Uma aplicação simples, mas que exigiu boa quantidade de gems.

Eu particularmente estava muito envolvido com o design, nesse projeto, e até já havia feito uma prévia de uma estante de livros um dia antes de começar o Rumble. Trabalhamos o sábado todo com essa tela, mas o sistema foi tomando forma e eu vi que se tornaria algo completamente diferente do que eu vinha imaginando. 11h do domingo (último dia do desafio) resolvi refazer o layout do zero. Foi uma decisão que titubiei bastante para tomar, mas que precisava ser tomada, e rápido, pois um dos pontos avaliados eram justamente a aparência. Refiz, e às 14h estava um layout completamente diferente no ar.

O desafio acabou às 21h (no Ceará). O resultado foi satisfatório, apesar de ter bastante arestas a serem aparadas (um erro chatinho quando se loga pela primeira vez, e outras coisitas mais). Justificável, se analisado que começamos no projeto somente às 12h do sábado.

Enfim, para mim, a prova da produtividade do Rails, de que trabalho em equipe é fundamental, e que, querendo (e sob pressão) quase tudo é possível.

Segue alguns links memoráveis do evento:

http://akitaonrails.com/2010/10/18/rails-rumble-na-gonow-retrospectiva – Retrospectiva do Akita

http://www.youtube.com/watch?v=kp0T1YCSLfc – Entrevista do Akita com a equipe Cangaceiros

http://razenha.wordpress.com/2010/10/20/rails-rumble-codigo-diversao/ – Retrospectiva do Azenha, que tava com a gente

http://twitpic.com/2ybbw4 – Flagra da transmissão ao vivo de algumas equipes brasileiras

Tudo começou quando, cansados do péssimo serviço da Velox (fornecida pela Oi através do plano Oi Conta total 3), resolvemos trocar por outra operadora de internet e fixo. Como não precisaríamos mais da internet nem do fixo (a portabilidade iria acontecer para a outra operadora), e eu não queria mudar de número, nem perder minha linha de celular, resolvi procurar um plano que fosse compensatório.

Soube de um plano numa das lojas da Oi onde tinha direito a 60 minutos para falar com qualquer operadora, e, logo após esses minutos, teria direito a mais 1.000 minutos para falar com Oi e fixo. Continha na promoção também um pagamento com desconto de 15 reais por mês durante os 10 primeiros meses e 30 mensagens grátis. Como eu já tinha uma linha, a vendedora me informou que a transferência só poderia ser realizado por telefone.

Aí me veio a dor de cabeça.

Na primeira ligação, a atendente foi super atenciosa, e entendeu perfeitamente o que eu queria. Perguntei repetidas vezes se eu teria direito ao bônus, e se o valor que eu pagaria teria o tal desconto prometido, ela me afirmou categoricamente que sim. Mas quando quis finalizar o serviço, ela verificou que havia uma pendência de portabilidade para a minha linha fixa, e a mudança só poderia acontecer após a finalização dessa pendência. Me afirmou, porém que minha solicitação iria ocorrer automaticamente após a finalização da pendência.

Após o prazo estipulado…

Liguei, e o atendente me informou que ainda estava pendente, porém a qualquer momento iria acontecer a tal mudança. Perguntei novamente se minha mudança do plano do celular ocorreria automaticamente, e ele me afirmou que sim, que constava minha solicitação de mudança do plano do Oi móvel.

Imediatamente após me comunicarem que havia ocorrido a portabilidade do fixo, o que ocasionaria o cancelamento do Oi Conta total, e então a mudança de plano, liguei para eles para conferir se havia mudado como solicitado. Minha surpresa foi justamente a atendente informar que meu plano tinha virado “Oi básico”

Como assim? Eu não solicitei isso, eu não queria isso, e eu deixei claro que eu queria outro plano. Me foi informado que esse era o “procedimento padrão”, assim que o Oi Conta total era cancelado, mudavam para o Oi Básico. Que diabos eu fiz pendurado 1h no telefone quando solicitei o serviço de mudança para o Oi 60 então? Me informaram que não tinha nenhuma solicitação pendente, e somente uma notificação no protocolo do primeiro atendimento fazendo menção a isso.

“Quero solicitar novamente, então”. Ok, mas não tem o desconto, pois você já é cliente Oi. COMO ASSIM? Sou cliente há mais de 5 anos e não tenho desconto para um novo serviço? Que idiotas! É assim que se fideliza um cliente? Que noção (ou falta dela!). Depois de 3 ligações para atendentes diferentes, todas me afirmaram que “não poderiam fazer isso por mim”. Mas não era um favor, era uma coisa que já tinham me vendido, já havia solicitado, e já tinha sido enganado. Como não consegui de forma alguma o desconto de 15 reais por mês, solicitei a migração assim mesmo.

Chateado, enganado, enfim achei que tinha conseguido. Mas não.

Depois de eu usar o telefone a vontade, acreditando que teria direito ao bônus, e extrapolar os 60min, meu irmão, para tirar a dúvida, ligou, e descobriu que na verdade não tinha o bônus. Isso porque não tem bônus para clientes. COMO ASSIM, MEU CHAPA?! Sabe o que eu deveria ter feito? Cancelado, feito a portabilidade para outra operadora, depois voltado para a Oi, assim teria todos os descontos. Mas eu não era o titular.

Enfim, meu irmão conseguiu depois de muita briga que eles colocassem a promoção.

Sobrou que… gastei meus 60min e excedi nos minutos. Terei que recorrer, pois a conta dará bem mais alta do que o imaginado.

ERROR:  Loading command: install (LoadError)
no such file to load — zlib
ERROR:  While executing gem … (NameError)
uninitialized constant Gem::Commands::InstallCommand

Para solucioná-lo, basta seguir as seguintes etapas:

rvm package install zlib
rvm remove 1.8.7 (no caso, a versão do seu Rails)
rvm install 1.8.7 (sim, a mesma que fora removida)

Pronto, agora ele será recompilado com a zlib.

Simples!

Claro que já tinha ouvido falar do Gimp. É a primeira opção que se recomenda e se pensa em qualquer lugar, mas, será que ele é bom mesmo? Dá para fazer as mesmas coisas que “um Photoshop da vida”? Tentava e tentava utilizar, mas sempre me deparava com uma ou outra coisa que me impedia de afirmar: “O Gimp presta!”

Minha visão mudou. Por quê? Porque meu “método de avaliação” mudou. Estava tentando procurar no Gimp as ferramentas e formas de trabalhar que eu estava acostumado no Photoshop. Esqueci que o que eu queria avaliar, na verdade, era se o Gimp era capaz de ser a ferramenta ideal para design gráfico. E descobri que sim.

Estaria mentindo se dissesse que é um software completo. Não é. Coisas básicas ainda faltam (algumas delas já prometidas para a próxima versão) como:

• Agrupamento de camadas (essa já é certeza sair na próxima versão)
• Desenho vetorial (existe uma implementação de vetor, mas praticamente só para seleções)
• Melhoria na ferramenta de Brush.
• Suporte a CMYK (no meu caso, desenho praticamente para a Web, então isso não é ponto falho)

Apesar dessas pequenas faltas, digo que é possível sim fazer trabalhos bons utilizando o Gimp. E digo que hoje não sinto falta do Photoshop. Não há nada no Gimp que não consiga fazer. Nada que eu precise, ao menos.

Tive que entender que para fazer um quadrado ou um círculo, tenho que selecionar uma área e pintá-la, ao invés de clicar numa ferramenta de círculo e escolher a cor interna. Perceberam que o que muda é somente a maneira de se fazer as coisas? O resultado final e o esforço para atingi-lo são os mesmos.

Meu primeiro exemplo real e prático de um trabalho feito 100% utilizando o Gimp foi o site www.gogs.com.br. Nele fiz questão de nem abrir o Photoshop. Nenhum momento sequer, e, julgo eu (falando de meu filho) que ficou bem bonitinho.

Para quem tem preguiça de acessar links de posts, segue abaixo um screenshot pequeno:

Desculpem-me não ter sido muito específico, mas utilizo este artigo mais para incentivar você também a descobrir que se pode fazer com o Gimp tudo o que deseja, e com um tempo outras ferramentas não vão fazer tanta falta.

Recentemente adquiri o HTC Touch com Windows Mobile 6.1 e imediatamente busquei formas de sincronizar com o Linux. Como já estava “treinado” pelas minhas tentativas anteriores com o 2630, não achei grandes dificuldades com esse Smartphone, pelo contrário, percebi que é até mais fácil.

Adicionando o repositório do SynCE

• Certifique-se que tem algum usuário criado no Evolution (programa de e-mails padrão do GNOME). Se não tiver, basta abrir o programa pela primeira vez e seguir os passos. Não precisa configurar um e-mail válido com servidor e tudo mais, será necessário apenas o usuário.
• Digite “sudo gedit /etc/apt/sources.list” e adicione a linha: “deb http://ppa.launchpad.net/synce/ubuntu jaunty main” (se for o caso da sua distribuição ser a Ubuntu Jaunty. Caso contrário, siga a seguinte lógica: “deb http://ppa.launchpad.net/synce/ubuntu VERSÃO main“. Salve e feche o arquivo.
• Adicione a chave pública. Copie o texto abaixo criando um arquivo e salvando com o nome “synce.key” na sua área de trabalho.

-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: SKS 1.1.0

mI0ESXQ6XAEEAOtHMAT/drqMvyLjUEZBXdhrZWH1JUnjp2jr/LrZlZiQTgb+KL0bEjh5fAvB
e1B1d0ewfRcosFiCLudk303yLv7SIB93YaM8u2k9/PhDtgRmoE379AzDWPAln5snZ8EnvN5u
FzOIoqVfptdMHQfHKr8ZNUMOI6r7Zh7iCFpg2JGVABEBAAG0F0xhdW5jaHBhZCBQUEEgZm9y
IFN5bkNFiLUEEwECACAFAkl0OlwCGwMGCwkIBwMCBBUCCAMEFgIDAQIeAQIXgAAKCRCxUvBC
0kbCXXaEA/dCubeqDKc6km37meBlXOkO9+AcZRh3zJLcbrFicze+Apdijue34MJxo+nlkwCI
Ayf2mHLbhD4+cKMzUp4n2ktKDf91dikcYmQyts17vN9wSM8RRNaKnZA0gQWSaNuDOJbkegQh
7tgpfzVHEvITL6dgsZcXz6zmUdrhC6nhHF4O
=Yrhm
-----END PGP PUBLIC KEY BLOCK-----

• Importe a chave para o Synaptic: Sistema > Administração > Gerenciador de pacotes Synaptic > Configurações > Repositórios > Autenticação > Importar arquivo chave
• Selecione o arquivo “synce.key” na área de trabalho e clique em “OK”.
• Abra o terminal e digite: “sudo apt-get update“

Até aqui você adicionou o repositório de arquivos do SynCE no seu sistema. O SynCE é o programa que fará a sincronização dos arquivos e dados do Windows Mobile com o Linux.

Acessando os arquivos do aparelho

• Digite “sudo apt-get install synce-hal synce-gnomevfs synce-gvfs synce-trayicon librra-tools librapi2-tools synce-sync-engine” e reinicie o Nautilus (melhor reiniciar o sistema todo).
• Conecte o Smartphone na entrada de USB.
• Entre no Nautilus (gerenciador de arquivos do GNOME) e digite “synce:///” na barra de “Localização”. Uma unidade chamada “Mobile Device” será mapeada e lá você terá total acesso aos arquivos contidos no aparelho.

Sincronizando agenda e contatos com o Evolution

• Digite “sudo apt-get install multisync-tools opensync-plugin-evolution opensync-plugin-synce multisync0.90“
• Conecte o Smartphone na entrada de USB. Um ícone de um smartphone irá aparecer ao lado do reloginho.
• Clique com o botão direito no ícone do reloginho e selecione: Pocket PC > View device status
• Crie um novo registro de dispositivo clicando em “Create” na aba “Partner”. Digite um nome e quais campos você deseja sincronizar com o Desktop.
• Abra o Multisync clicando em: Aplicativos > Acessórios > Multisync-gui
• Clique em “Adicionar” e dê um nome ao dispositivo (pode ser “celular”, “mobile”, “seu nome”)
• Clique em “Editar”. Na janela que aparecer, clique em “Add member” e selecione “Plugin to syncronize with Windows Mobile 5 and later devices
• Adicione um novo membro clicando novamente em “Add member” e selecionando “Evolution 2.x”
• Feche a janela “Editar” e clique em “Atualizar”.

Pronto, agora você acabou de sincronizar os dados do celular com o computador. Se houver algum conflito de dados (alteração em alguma das partes) ele irá perguntar qual versão você quer que sobrescreva a outra. Sempre que quiser sincronziar, basta abrir o Multisync e clicar em atualizar.

E no Ubuntu 9.10 Karmic Koala?

Quando escrevi esse artigo estava utilizando o Ubuntu 9.04 e ele funcionou que é uma beleza, porém ao atualizar para o 9.10 notei (assim como os muitos colegas que o comentaram) que ele não funcionava. (O repositório do ppa launchpad já foi atualizado. Basta colocar “deb http://ppa.launchpad.net/synce/ubuntu karmic main” à lista de repositórios)

Em minhas diversas tentativas só encontrei (por enquanto) uma saída. Para realizá-la, já atualizei os pacotes na lista acima, então você pode seguir os mesmos passos descritos acima para a instalação dos pacotes. A lista de procedimentos acima está compatível com versões anteriores ao Karmic Koala e a ele. Haverá apenas um pacote adicional a ser instalado, que fará o gerenciamento de arquivos do seu celular. Infelizmente não consegui abrir pelo Nautilus:

• No terminal, digite “sudo apt-get install gpe-filemanager“
• Após instalar, abra o programa “Aplicativos > Sistema > File Manager”
• Digite “synce://” na barra de endereços. E pronto!

Para o sincronizmo, realize todas as etapas descritas em “Sincronizando agenda e contatos com o Evolution”, exceto a última, e então:

• No terminal, digite “msynctool –listgroups“. Note que vai aparecer o nome do grupo criado no Multisync
• Digite então “msynctool –sync NOME_DO_GRUPO“. E pronto!

Addictive Drums

Há um tempo postei uma dica no blog Linux Vst Compatibility indicando os passos para instalar o Addictive Drums no Linux.

O Addictive Drums é um fantástico VSTi (instrumento virtual) de bateria que pode ser utilizado com um teclado ou pads de bateria eletrônica. Para mim é o drum kit mais convincente que encontrei, daí o meu esforço em consegui-lo fazer rodar no Linux.

Primeiramente você precisará ter o DSSI-VST instalado. Demonstrei os passos em outro artigo do meu blog: Compilando o DSSI-VST ou então baixando um pacote de instalação para o Ubuntu: Instalando o DSSI-VST facilmente com um .deb. Em seguida, complete os seguintes passos:

• Instale o Addictive Drums completo.
• Na pasta .wine/Program Files/XLN Audio/, entre em “Addictive Drums” e copie as pastas “Sound Data” e “Factory Presets” para algum lugar temporário.
• Copie os arquivos “GUIData.xpak” e “Resources.xpak” para o mesmo lugar.
• Copie o arquivo .wine/Program Files/VST Plugins/Addictive Drums.dll para o mesmo lugar.
• Desinstale o Addictive Drums completo

…agora, baixe o Addictive Drums Demo no site da XLN Audio e…

• Instale Addictive Drums Demo
• Na pasta .wine/Program Files/XLN Audio/, entre em “Addictive Drums Demo” e apague (ou, se preferir, crie um backup antes, para então remover) as pastas “Sound Data” e “Factory Presets” e os arquivos “GUI Data.xpak” e “Resources.xpak”. Então substitua pelos arquivos que você havia salvado na pasta temporária anteriormente.
• Substitua o arquivo “Addictive Drums.dll” na pasta “VST Plugins” também.
• Execute o Addictive Drums no DSSI-VST digitando “vsthost Addictive Drums.dll” na shell.

Se não carregar nenhum preset assim que carregar, você precisará fazer isso manualmente. Clique na barra de preset (no topo, à esquerda) e escolha algum preset. É isso! Os arquivos da bateria irão ser carregados.

Fiz isso no meu Ubuntu 9.04 com o DSSI-VST 0.8.

Em inglês / In english

Vale ressaltar que o pacote criado foi o dssi-vst0.8 no Ubuntu 9.04. Se você está querendo utilizar em outra versão do Ubuntu ou no Debian, ou em outra distribuição, não posso garantir que vá funcionar, apesar de crer que outras versões do Ubuntu não irão divergir ou dificultar a instalação.

Basta baixar e clicar duas vezes para começar a instalação.

Você pode baixar o arquivo .deb no seguinte link: http://www.4shared.com/file/130990149/7b7c979e/dssi-vst_08-1_i386.html

Para compilar para a sua distribuição, siga os seguintes passos: http://henriquegogo.wordpress.com/2008/05/27/compilando-o-dssi-vst/

De início, utilizar o vim parece um “parto”. Tudo é comando, as teclas de atalho mais conhecidas não funcionam, aquela interface simples chega a dar repulsa. Felizmente, isso passa. Nada do que um bom :help para aprender a mexer mo bichinho. Seguir o tutorial padrão do sistema é uma ótima ideia para se aprender o básico, e, daí, aproveitar o máximo que esse editor de textos pode proporcionar.

Uma das características principais do vim é sua customização. Praticamente tudo é customizável, e até programável. A possibilidade de fazer plugins e outras coisas mais como “syntax highlight” vão incrementando sua área de edição a ponto de deixar da maneira que você quiser.

Já utilizo o vim há um tempo, inicialmente para montar HTML + CSS e atualmente para programar em Rails. Praticamente abandonei o Eclipse e o Aptana para utilizar somente o vim. Para chegar a tal ponto de “migrar” de IDE, tive que passar por um relativo processo de customização do editor para que ele ficasse “no ponto”. Existe um arquivo chamado “.vimrc” na pasta raiz da aplicação. É lá que você vai aplicar as alterações propostas nesse artigo.

O arquivo que disponibilizo é uma versão customizada do vim criada por mim, e está todo comentado.

Inicialmente, recomendo a instalação dos seguintes plugins:

• NERDTree :: Lista os arquivos em árvore
• colorsel :: Seleciona uma cor hexadecimal
• html_autoclosetag :: Fecha as tags HTML com seu “par”
• ir_black :: Color scheme elegante e organizado

Depois, instale um corretor ortográfico da língua portuguesa. Para isso você precisará ter a versão 7 ou superior do vim.

• Faça o download do dicionário
• Descompacte o arquivo
• No vim, digite o comando ‘:mkspell pt /caminho/do/descompactamento/pt_BR’
• Copie o arquivo gerado para a pasta ~/.vim/spell/
• Ative a correção: ‘:set spell’
• Escolha o dicionário: ‘:set spelllang=pt’

Pronto, esses são os plugins que eu recomendo para a utilização do vim e transformá-lo numa verdadeira IDE, mas não basta só isso. Vamos agora para o principal: o arquivo de configuração .vimrc. Eu configurei um arquivo que pode ser utilizado tanto no vim para windows como na versão linux. Peguei um apanhado de configurações da internet e personalizei ao meu gosto. Acredito que provavelmente seja do gosto da maioria.

Se você utiliza o vim no Windows, adicione seguinte linha no início do arquivo:

source $VIMRUNTIME/vimrc_example.vim

Abaixo, o arquivo comentado e explicado.

"""""""""""""""""""""""""""""""""""
" CONFIGURAÇÕES PADRONIZADAS GOGS "
"""""""""""""""""""""""""""""""""""

set number                    " Numera as linhas
set nobackup                  " Não salva arquivos de backup~
set wildmode=longest,list     " Completa o comando com TAB igual o bash

set ignorecase                " Ignora o case sensitive nas buscas
set smartcase                 " Se tiver alguma letra maiúscula, ativa o case sensitive

set smartindent               " Auto-indenta
set expandtab                 " Identa com espaços

set tabstop=2                 " Quantidade de espaços por identação
set shiftwidth=2              " Quantidade de espaços da auto-indentação

set guioptions-=T                    " Deixa a GUI sem a toolbar
set autochdir                 " Vai pro diretório do arquivo aberto

" Corretor ortográfico
set spelllang=pt              " Escolhe o dicionário

" Inicia no modo INSERT
set im
imap <ESC> <C-L>

" Cria e escolhe as abas
noremap <C-T> :tabnew<CR>
noremap <C-TAB> :tabnext<CR>
noremap <C-S-TAB> :tabprevious<CR>
inoremap <C-T> <C-O>:tabnew<CR>
inoremap <C-TAB> <C-O>:tabnext<CR>
inoremap <C-S-TAB> <C-O>:tabprevious<CR>

" Mover texto com os TABs
vnoremap < <gv
vnoremap > >gv
noremap <TAB> >
noremap <S-TAB> <

" Auto-fecha parênteses, chaves etc.
"inoremap { {}<LEFT>
"inoremap ( ()<LEFT>
"inoremap [ []<LEFT>
"inoremap " ""<LEFT>
"inoremap ' ''<LEFT>

" Move linhas ou blocos usando ALT+SETA
nnoremap <A-DOWN> mz:m+<CR>`z==
nnoremap <A-UP> mz:m-2<CR>`z==
inoremap <A-DOWN> <Esc>:m+<CR>==gi
inoremap <A-UP> <Esc>:m-2<CR>==gi
vnoremap <A-DOWN> :m'>+<CR>gv=`<my`>mzgv`yo`z
vnoremap <A-UP> :m'<-2<CR>gv=`>my`<mzgv`yo`z

" Deleta linha com CTRL+D
noremap <C-D> dd
vnoremap <C-D> <C-C>dd
inoremap <C-D> <C-O>dd

" Organiza identação de um bloco selecionado com CTRL+ALT+F
noremap <C-A-F> ==
vnoremap <C-A-F> <C-Q>==
inoremap <C-A-F> <C-O>==

" Command-line com CTRL+ALT+C
noremap <C-A-C> :
vnoremap <C-A-C> <C-Q>:
inoremap <C-A-C> <C-O>:

" Busca com CTRL+F
noremap <C-F> /
vnoremap <C-F> <C-Q>/
inoremap <C-F> <C-O>/

" Abre arquivos com CTRL+O
noremap <C-O> :tabnew
vnoremap <C-O> <C-Q>:tabnew
inoremap <C-O> <C-O>:tabnew 

" Função que usa o omnicomplete apenas com o CTRL+SPACE
inoremap <C-SPACE> <C-X><C-O>
filetype plugin on

"""""""""""""""""""""""""""""
" Atalhos comuns de teclado "
"""""""""""""""""""""""""""""

" Permite selecionar com SHIFT + SETA como no Windows
set selectmode=mouse,key
set mousemodel=popup
set keymodel=startsel,stopsel
set selection=exclusive

" Backspace no modo de visão apaga a seleção
vnoremap <BS> d

" CTRL-X e SHIFT-Del corta
vnoremap <C-X> "+x
vnoremap <S-Del> "+x

" CTRL-C e CTRL-Insert copia
vnoremap <C-C> "+y
vnoremap <C-Insert> "+y

" CTRL-V e SHIFT-Insert cola
noremap <C-V>        "+gP
noremap <S-Insert>   "+gP
inoremap <C-V>       <C-O>:set nosi<CR><C-R>+<C-O>:set si<CR>
inoremap <S-Insert>  <C-R>+
cnoremap <C-V>       <C-O>:set nosi<CR><C-R>+<C-O>:set si<CR>
cnoremap <S-Insert>  <C-R>+

" CTRL-S salva
noremap <C-S>  :update<CR>
vnoremap <C-S> <C-C>:update<CR>
inoremap <C-S> <C-O>:update<CR>

" CTRL-Z desfaz
noremap <C-Z> u
vnoremap <C-Z> <C-C>u
inoremap <C-Z> <C-O>u

" CTRL-Y refaz
noremap <C-Y> <C-R>
inoremap <C-Y> <C-O><C-R>

" CTRL-A seleciona tudo
noremap <C-A> gggH<C-O>G
inoremap <C-A> <C-O>gg<C-O>gH<C-O>G
cnoremap <C-A> <C-C>gggH<C-O>G
onoremap <C-A> <C-C>gggH<C-O>G
snoremap <C-A> <C-C>gggH<C-O>G
xnoremap <C-A> <C-C>ggVG

" CTRL-F4 fecha a janela
noremap <C-F4> <C-W>c
inoremap <C-F4> <C-O><C-W>c
cnoremap <C-F4> <C-C><C-W>c
onoremap <C-F4> <C-C><C-W>c

""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
" Opções de plugins (Retire essas linhas se não tiver estes plugins) "
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""

colorscheme ir_black                                              " Escolhe o tema
au BufNewFile,BufRead *.txt source ~/.vim/syntax/txt.vim          " Carrega o arquivo de sintaxe para TXT

" Atalhos para plugins
noremap <F5>  :NERDTree<CR>
noremap <F7>  :set spell<CR>z=
inoremap <F5> <C-O>:NERDTree<CR>
inoremap <F7> <C-O>:set spell<CR><C-O>z=

"""""""""""""""""""""""
" Informações e dicas "
"""""""""""""""""""""""
" Plugins recomendados:
" - NERDTree :: Lista os arquivos em árvore
" - ir_black :: Colorscheme bem bonito
" - txt.vim :: Sintaxe para arquivos de texto feito pelo aurelio.net
" - jquery.vim :: Sintaxe para arquivos jquery.vim
" - html_autoclosetag :: Fecha as tags HTML automaticamente
" - snipMate :: Autocompleta funções inteiras
"               Para que o <tab> do snipMate não anule o TAB para identar
"               blocos, edite o arquivo ~/.vim/after/plugin/snipMate.vim
"               substituindo os mapeamentos 'ino' por 'imap' como no ex.:
"               imap <silent> <tab> <c-r>=TriggerSnippet()<cr>
"               imap <silent> <s-tab> <c-r>=BackwardsSnippet()<cr>
"               imap <silent> <c-r><tab> <c-r>=ShowAvailableSnips()<cr>
"               Apague todas as linhas começadas por 'snor'.
"
" Corretor ortográfico em português brasileiro:
" - Faça o download do dicionário em: http://www.broffice.org/verortografico/baixar
" - Descompacte o arquivo
" - No vim, digite o comando ':mkspell pt pt_BR'
" - Copie o arquivo pt.utf-8.spl gerado para a pasta ~/.vim/spell/
" - Ative a correção: ':set spell'
" - Escolha o dicionário: ':set spelllang=pt'

Recentemente trabalhei no desenvolvimento de um sistema de indicações de oportunidades de negócios. O sistema era bem simples, e o desenvolvimento só não foi mais rápido pois foi o primeiro projeto adotado a ser desenvolvido em Ruby on Rails pela empresa. Como já citei num artigo anterior, “as primeiras semanas foram doloridas. Pensar tudo de trás para frente, uma nova linguagem, e tudo o mais que uma migração assim nos permite sofrer, pode ser um pouco dolorido, mas vale a pena.”

Uma das coisas que passei mais sufoco foi, com certeza, a dificuldade de configurar um servidor de entrega. Diversos fatores entraram em questão, a própria decisão de qual máquina seria escolhida, a criação da máquina virtual (já haviam outras máquinas virtuais instaladas) e outras particularidades que não dizem respeito ao RoR.

Se tratava de um servidor simples, que seria utilizado apenas para mostrar aos clientes o sistema funcionando e permitir que eles pudessem “brincar” um pouco com o sistema. Pensei logo: “ora, já usamos o Webrick para testes locais, logo não encontraremos problemas.” Mas não foi bem assim.

Rodar o Webrick localmente pode fazer tudo o que você pretende, mas tente rodar de um IP remoto. Pensando bem, tente rodar utilizando seu póprio IP da rede (não vale 127.0.0.1). No caso do nosso sistema, o carregamento de uma página simples de login durava cerca de 3 min. Quando entrava, enfim, no sistema, além da demora, alguns elementos (imagens) não eram carregadas. O Webrick era a grande dor de cabeça.

Parece besteira de iniciante. E realmente era, mas naquele momento eu simplesmente não poderia ter perdido tanto tempo com isso.

A segunda tentativa que nos parecia óbvia foi instalar o Passenger: um mod_rails para o Apache que supostamente seria a opção mais viável. A instalação não foi tão diferente quanto qualquer mod para Apache, e suas configurações. O problema foi a inconstância do pacote e das gems. Primeiro que é quase impossível desinstalar a gem. Quando assim o fiz, simplesmente a gem continuava lá na “gem list”, mesmo desinstalada. Depois de formatarmos a máquina virtual e instalarmos tudo do zero novamente, funcionou perfeitamente. Nos demos por satisfeitos.

No dia seguinte, sem maior explicação ou alguém ter sequer acesso ao servidor, o passenger não funciona mais. E isso já era véspera da entrega do sistema. Algo assim não poderia falhar. Não era uma opção.

A essa altura, depois de muitas tentativas de correção, já havíamos desistido de entregar através do servidor de testes. Continuamos o desenvolvimento do sistema, pois alguns tópicos precisavam ser finalizados.

Dia seguinte, dia de entrega. Lendo alguns artigos em blogs que tratavam de Rails, me veio a possibilidade de testar o Mongrel. Fui meio sem esperança, pensando se tratar de algo “como o Webrick”, que serviria apenas para testes locais. A instalação é bastante simples, não passando de um “gem install mongrel”. Para rodar, bastava digitar “mongrel_rails start”. Nenhuma configuração foi necessária, nenhuma palha foi mexida, nada mais foi feito. Simplesmente duas linhas e lá estava meu servidor de testes funcionando e rodando a aplicação perfeitamente.

Em 2 min concluí uma operação que me custou cerca de 20 horas sem sucesso. Mais tarde, ao me aprofundar e ler casos de uso, descobri que o mesmo servidor Mongrel é o servidor Rails utilizado pelo Twitter. Sem sombra de dúvidas, poderia ser facilmente utilizado no servidor final, de produção.

Se trata de pensar como o cliente, e dar ao cliente o que ele precisa, logo de cara, para evitar alterações no sistema e tornar o processo de produção e desenvolvimento algo “palpável”, direto e real.

Tenho apreciado bastante Metodologias Ágeis, principalmente XP (eXtreming Programing) e isso tem tudo a ver com o que eu estou falando: a partir das iterações (reuniões periódicas), apresentar pequenas funcionalidades e etapas do projeto, ao invés de simplesmente estipular um prazo X e tentar correr para cumpri-lo, e até lá o cliente fica “na mão”.

Um ótimo livro que recomendo para a leitura que fala justamente disso é o “Getting Real” (Caia na Real, em tradução livre), recomendado pelo caríssimo Clavius Tales.

Pensando no layout primeiro

Uma das coisas que mais emperram um projeto é cliente que cisma com pequenas coisinhas do projeto. As vezes um tempo valiozo é perdido ajeitando-se “bugs” de layout, ou erros de português, enquanto que poderia-se estar desenvolvendo funcionalidades que tornariam o sistema realmente funcional.

Sendo assim, a prototipação entra em primeiro lugar. De que adianta mostrar ao cliente um cadastro sendo efetuado sob uma aparência completamente irreal? O próprio cliente se tornaria mais interessado e já teria “algo nas mãos” se o layout fosse pensado e realizado inicialmente, além de evitar que toda uma equipe seja deslocada para o desenvolvimento.

Não diria que tudo do sistema deveria ser desenhado previamente, mas ao menos todas as funcionalidades solicitadas para a primeira etapa do

Cito aqui um trecho do livro de Seth Godin: http://gettingreal.37signals.com/GR_por.php#ch09

Desenhe a interface antes de começar a programar

Muitos aplicativos começam com a mentalidade de programar primeiro. Isso é uma má idéia. Programação é o componente mais pesado de construir em um aplicativo, significando ser o mais caro e mais difícil de mudar. Ao invés disso, comece desenhando primeiro.

Design é relativamente leve. Um esboço de papel é barato e fácil de mudar. Rascunhos HTML são relativamente simples de modificar (ou jogar fora). Isso não é verdade na programação. Desenhar antes deixa você flexível. Programar primeiro prende você e gera custos adicionais.

Outra razão para projetar primeiro é que a interface é o seu produto. O que as pessoas vêem é o que você está vendendo. Se você somente rabiscar uma interface no final, os buracos vão aparecer.

Nós começamos pela interface para que possamos ver como o aplicativo será desde o começo. Este será constantemente revisado no decorrer do processo. Isso faz sentido? É fácil de usar? Ele resolve um problema de imediato? Existem perguntas que você só poderá realmente responder quando você lidar com telas reais. Desenhar antes deixa você flexível e o leva para essas respostas no processo mais cedo do que mais tarde.

WebDesigner e Designer de Interação têm espaço garantido

Já não dá mais para pensar em programar só código e desmerecer o layout. Lembre-se que a maior parte do contato que o usuário vai ter com seu sistema será o layout e as facilidades ou dificuldades que a interface irá proporcionar a ele. Não se dê ao luxo de não precisar de alguém que faça um design bacana do seu sistema, só para economizar uma grana com salário ou serviço “por fora”. Hoje em dia sistemas pouco intuitivos não têm mais espaço no mercado.

Sabe-se que a grande maioria dos usuários só utilizam uma pequena porcentagem das ferramentas que os sistemas dispõem. Então para quer pensar em tudo, e acabar oferecendo um trem complicado de pilotar? Por que não oferecer uma bicicleta para o seu cliente, e, aos poucos ir incrementando rodinhas e outras coisas mais até ela se tornar uma Harley Davidson?

O Designer de Interação tem a visão necessária para entender o que realmente precisa estar ali e o que é inutil para o cliente. Um exemplo bem prático é o MSN. Alguém já leu algum tutorial ou manual de MSN? Porém todos sabem mexer. É uma ferramenta simples, mas super útil. Pense bem nisso antes de querer fazer um sistema de chat com suporte a mediadores e diversas salas e sub-salas com usuários X que fazem Y coisas. Pense simples! Caia na real.