Blog do Grasselli

Meu ambiente de desenvolvimento

2011-01-02T17:18:00.000-02:00

O pessoal da comunidade Ruby começou com a ideia de cada um descrever seu ambiente de trabalho em seu blog e passar a bola para outros desenvolvedores. O Rafael Rosa me pois na brincadeira e estou aqui postando o meu ambiente. É uma boa pra ver se eu animo a postar no blog de novo, desde o começo de outubro que eu não posto.

Máquina / Sistema operacional

Atualmente tenho trabalhado em um Mac mini, com sistema operacional Mac OS X (Snow Leopard). Na verdade aonde estou estamos usando estações de pareamento, são 3 Mac minis, cada um com dois teclados, dois mouses e dois monitores, e 5 ou 6 desenvolvedores se revezam para usá-los.

Ainda não estou muito certo se prefiro linux ou mac para trabalhar, sempre usei linux no serviço (geralmente ubuntu) e um macbook em casa. Ultimamente estou com mac no serviço também, a experiência está sendo boa apesar de que por algum estranho motivo eu me sinto mais rápido num linux. Talvez eu goste mais do terminal do linux.

Terminal

Como um desenvolvedor ruby tenho a felicidade de ter um terminal aberto 100 % do meu tempo. Não conseguiria trabalhar com um sistema operacional sem um bom terminal.

Geralmente deixo uma aba aberta para o log do servidor local e outra para uso genérico. Quando estou no Linux costumo usar o Vim dentro do terminal como editor de textos, então uma aba fica reservada pra ele. No mac acabo usando o Mvim, porque no terminal do mac o vim não fica muito legal.

Editor

Como já falei no tópico acima, meu editor de textos é o Vim. Já uso ele há uns 2 ou 3 anos e não o troco por nenhum outro. Lógico que em algumas linguagens uma IDE é totalmente necessária, mas como trabalho com Ruby um bom editor de textos (como o Vim) é mais do que suficiente.

Não uso o vim porque me acho mais rápido com ele ou algo do gênero. Uso ele por afinidade mesmo. Me sinto muito bem com ele, gosto de aprender comandos novos com frequência e acho ele uma ideia genial. E, lógico, depois de um tempo usando me tornei mais rápido nele do que nos outros.

Navegador

Para desenvolver eu sou 100% Firefox, não consigo usar outro. Para uso pessoal eu já passei por vários, opera, firefox, chrome e já faz uns meses que estou testando o Safari, tenho gostado.

Outros

Bom, é isso, dentre outras coisas uso o Git para versionamento, algumas ferramentas que desenvolvo para uso pessoal para facilitar algumas tarefas, como o Donald para solucionar conflitos no Git. Uma boa ferramenta de integração contínua é essencial em uma equipe também. Não escuto música enquanto desenvolvo, mas converso bastante.

Passo a bola pro Ricardo Bernardelli, Renato Nitta e para o Maurício de Amorim.

Abraços.

Como sua equipe lida com open source?

2010-10-14T22:41:00.000-03:00

Nos últimos anos tenho a felicidade de ter trabalhado em equipes que utilizam open source para o desenvolvimento de suas aplicações e percebo entre as equipes algumas diferenças em como elas lidam com isso.

Acredito que a partir do momento que você escolhe usar tecnologias abertas, a forma com que sua equipe lida com esse tipo de desenvolvimento pode ser crucial para a produtividade e o bom andamento do projeto.

Vou listar alguns comportamentos diferentes que você pode ter:

Acho que Open source é como qualquer outro tipo de software (Rendimento baixo)

Você, ou sua equipe, acha que open source é como qualquer outra forma de desenvolvimento, a única diferença é que ela na maioria das vezes é gratuita.
Você acha que ela está lá para te servir, que basta instalar, rodar, e tudo tem que funcionar como as outras tecnologias fechadas que você está acostumado.
Você reclama quando encontra falhas na aplicação, e começa a usar isso de desculpa para o desempenho da equipe.

Pode até ser que, em projetos maiores e mais consolidados (ubuntu, mysql, apache), um comportamento como esse não seja tão prejudicial. Mas pensando em projetos menores, como o próprio Rails ou Ruby Gems, uma postura como essa não lhe trará um bom aproveitamento.

Sou apenas um usuário (Rendimento médio)

Você entende melhor como funciona o desenvolvimento open source, mas se posiciona como mero usuário.
Se algo não atende suas necessidades você procura por outras soluções ou espera até que o problema seja resolvido.
Você acha que é um grande problema quando algo assim acontece, pois sabe que vai impactar o rendimento da equipe.

Esse tipo de comportamento é um pouco melhor do que o anterior. Equipes em que trabalhei que agiam assim com o tempo até acabavam sendo mais críticas para escolher entre as tecnologias (vendo se o projeto ainda é ativo, reputação, etc) e acabavam contornando problemas, mas ainda eram meros usuários e de vez em quando travavam por problemas não tão complexos.

Eu contribuo (Rendimento alto)

Sua equipe sabe o que é open source e lida com ele com espírito de contribuição
Se algo não atende suas necessidades você:

faz um fork do projeto e manda um patch pra equipe que o está desenvolvendo
cria um outro projeto open que faça o que você precisa (se os que existem são muito diferentes da sua necessidade)
entra em contato com com a equipe que o desenvolve e reporta o seu problema (e se possível os ajuda a solucioná-lo)

Fica feliz quando encontra um bug pois ve uma oportunidade de contribuir

Essa situação eu encontrei na equipe que trabalho no momento (Gonow) e foi surpreendente ver o quão mais produtivo é trabalhar assim.

Contribuindo para os projetos você atende suas necessidades de uma forma mais rápida. Você não precisa esperar até que alguém resolva seu problema, o código está lá e equipes open source são extremamente receptivas e gratas por receber patches e novas features (portanto que sigam o foco do projeto e as regras para contribuição).

Contribuir não é tão difícil quanto parece, você vai melhorando aos poucos, vai entendendo melhor como cada projeto funciona, aumenta sua capacidade de ler e entender código dos outros, ve bons exemplos de códigos, entre outros. Só há ganhos.

Você até treina seu inglês!

Lançar projetos open source também é de grande valia. Em um projeto la na Gonow precisávamos de algo que calculasse distâncias entre lugares. Existiam gems que calculavam mas todas faziam isso a partir do raio, nenhuma fazia a partir da rota. Desenvolvemos nossa solução para isso (o go_maps) e o lançamos como open source. Tivemos ganhos logo nos primeiros dias, pois alguns usuários reclamaram de coisas que ele não tinha e percebemos que íamos precisar também. Tivemos esse feedback antes mesmo de lançar nosso projeto aos clientes.

Portanto fica a dica, se você pretende usar open source, saiba que não é apenas um software gratuito, ele é um software colaborativo. Incentive sua equipe a contribuir, se possível dediquem tempo do próprio projeto para isso, uma vez que esses softwares são parte do projeto.

É isso pessoal, nos vemos amanhã no Rails Rumble!

Ser ágil não é fácil

2010-09-15T22:04:00.000-03:00

Trabalhando há algum tempo em equipes ágeis percebo que algumas coisas não são muito bem compreendidas por quem decide formar uma equipe assim, em boa parte dos casos.

O que mais percebo em conversas, ou até em algumas equipes que já trabalhei, é que o desenvolvimento ágil muitas vezes é visto pelo gerente como uma ferramenta para motivar a equipe. O pessoal fica feliz porque está trabalhando com tendências da moda, cola post it aqui e ali e tudo flui bem, tudo continua como era antes, apenas diminuímos a documentação.

Se você pensa assim, saiba que pode está cometendo um grande erro e você pode levar seu projeto a falência.

Ser ágil não é fácil como parece, os princípios por trás do manifesto exigem uma equipe muito bem preparada.

Nossa maior prioridade é satisfazer o cliente, através da entrega adiantada e contínua de software de valor.

O principal objetivo de ser ágil é entregar valor ao cliente, entregar cedo e de forma contínua. Para chegar a esse objetivo você não vai desenvolver em módulos, fazer toda uma parte do sistema e depois ir pra outra e não voltar nessa parte tão cedo. Você vai desenvolver um todo, que funciona, de forma simples, e ficar melhorando todas as partes desse todo incrementalmente e continuamente.

Isso exige muito mais maturidade da equipe do que um projeto não ágil. Para fazer essa refatoração contínua (e criação de novas funcionalidades) nesse sistema em constante mudança você vai precisar de, no mínimo, uma ótima cobertura de testes.

Aceitar mudanças de requisitos, mesmo no fim do desenvolvimento. Processos ágeis se adequam a mudanças, para que o cliente possa tirar vantagens competitivas.

Se entrega de valor já faz com que você tenha que adaptar e evoluir um código constantemente, imagine mudanças de requisitos no meio do projeto.

Aonde eu quero chegar

O que eu estou querendo dizer com isso tudo é que desenvolvimento ágil na minha opinião é a maneira mais eficaz de se desenvolver software, se a decisão for minha eu com certeza vou optar por ela. Mas que fique bem claro que essa é uma forma de desenvolvimento difícil, que exige bastante da equipe.

Chegaria até a dizer que não é viável criar uma equipe ágil apenas com desenvolvedores inexperientes. Digo isso porque geralmente uma equipe iniciante, para atender à demanda flexível de um projeto ágil, acaba criando código difícil de lidar e, em pouco tempo, gera um projeto engessado, difícil de expandir.

Lembre-se:

Processos ágeis promovem um ambiente sustentável. Os patrocinadores, desenvolvedores e usuários, devem ser capazes de manter indefinidamente, passos constantes.

A velocidade de entrega de valor deve ser constante, mesmo após um tempo de projeto.

Se você gerente, deseja formar uma equipe ágil, tome essa decisão de forma consciente, sabendo que há muito trabalho à fazer, que será preciso investir na equipe. Que desenvolvimento ágil exige muito comprometimento por parte de todos e aponta falhas.

Uma vez que você sabe que desenvolvimento ágil não é mais fácil ou mais tranquilo que os demais e mesmo assim deseja adotá-lo, querendo obter o real valor dele, seja bem vindo =)

Porque eu escrevo os testes antes

2010-08-25T23:39:00.000-03:00

Depois de um bom tempo insistindo, e com a ajuda também do pessoal da minha equipe que sempre incentivou (exigiu? =P) essa prática, hoje em dia já se tornou natural para mim escrever o teste antes da implementação.

Minha ideia ao escrever esse post é lhe dizer alguns motivos de porque eu acho que você também deveria fazer isso.

#1 Uma prática de design

Já dizia o pessoal do livro The Rspec Book que BDD não é uma prática de testes e sim uma prática de design. Usamos o BDD para nos guiar sobre o que deve ser criado para satisfazer as necessidades de nosso produto, sem desperdícios. Se você escreve o teste depois você não se beneficia disso.

#2 Não se influenciar pela implementação

Quando você escreve o teste você deve se concentrar no que você espera de sua aplicação, sem pensar em como você vai implementar isso. Se você pensar na implementação antes ou, pior, você implementar antes do teste, você pode criar um teste influenciado pela implementação. O que pode fazer com que sua implementação tenha mais coisa do que o necessário e, ainda, pode fazer com que seu teste saiba demais sobre a implementação e a engesse.

Você deveria poder trocar a implementação sem precisar alterar o teste (refatoração), se seu teste sabe demais sobre a implementação, talvez você não consiga fazer isso e tenha grandes prejuízos (todo mundo tem que ficar alterando os testes a cada mudança).

Escrever o teste antes vai deixar seu código mais enxuto e sem desperdícios, focando apenas no necessário.

#3 Mais fácil se certificar que o teste funciona

Quando você escreve o teste antes você faz com que ele falhe e, após a implementação, ele deve passar. Isso já é uma prova de que seu teste está cobrindo o que você está criando. Se você escreve o teste depois você não tem tanta certeza sobre essa cobertura e, se você não tem o costume de retroceder a parte implementada pra ver se o teste realmente falha, talvez você crie testes que não cubram nada de novo.

#4 Não ter o "dever" de escrever o teste depois

Se você escreveu antes você usufruiu de diversos benefícios e no final já estava com tudo pronto, o teste realmente se mostra parte do desenvolvimento (o que ele é de fato). Se você não o fez, no final de tudo você ainda tem que escrever os testes, o que pode parecer um fardo (tudo está "pronto" e eu tenho que "perder" tempo com o teste).

Concluindo

Se sua equipe escreve testes depois, eu lhe digo que vale muito a pena tentar mudar essa ordem. Diria até que não faz sentido escrever o teste depois.

Não é tão difícil assim obter essa prática, basta um pouco de disciplina e, se precisar de ajuda, dicas sobre como testar determinada coisa, me coloco a disposição pra conversar. Não sou nenhum expert de testes, mas gosto bastante de falar sobre o assunto, me adiciona no gtalk, e-mail, twitter ou o que você preferir que eu tento ajudar com o que eu puder.

Até o próximo post!

Identificando specs lentos com rspec

2010-08-21T15:59:00.005-03:00

Recentemente em um projeto me passaram a tarefa de diminuir o tempo de execução dos testes, para facilitar a integração contínua.

Lembrei então de um comando do rspec que havíamos usado em um projeto anterior que facilita muito a tarefa de identificar quais são os testes críticos.

Não sei quantos conhecem (eu não conhecia há dois projetos atrás), mas um dos formatos do rspec é o "profile", que mostra no final dos testes um top 10 dos mais lentos e o tempo que cada um demorou.

Basta executar assim:

spec spec/ -f profile

ou, em sua versão resumida:

spec spec/ -f o

O resultado é similar ao abaixo:

Profiling enabled.

..................

Top 10 slowest examples:

0.0011200 Donald::MergeTool with $EDITOR variable not seted up with unmerged files with --vim argument should call vim

0.0010110 Donald::MergeTool with $EDITOR variable not seted up with no unmerged files should send an error message

0.0009800 Donald::MergeTool with $EDITOR variable not seted up with unmerged files with no arguments should call vim

0.0009340 Donald::MergeTool with $EDITOR variable as mate with unmerged files with no arguments should call mate

0.0009170 Donald::MergeTool with $EDITOR variable not seted up with unmerged files with --gvim argument should call gvim

0.0008920 Donald::MergeTool with $EDITOR variable not seted up with unmerged files with -g argument should call gvim

0.0008910 Donald::MergeTool with $EDITOR variable not seted up with unmerged files with -t argument should call textmate

0.0008830 Donald::MergeTool with $EDITOR variable not seted up with unmerged files with --mvim argument should call mvim

0.0008820 Donald::MergeTool with $EDITOR variable not seted up with unmerged files with --textmate argument should call textmate

0.0008750 Donald::MergeTool with $EDITOR variable not seted up with unmerged files with -m argument should call mvim

Finished in 0.026412 seconds

18 examples, 0 failures

Como eu uso o GIT

2010-06-03T13:53:00.009-03:00

Recentemente vi um post do Yehuda Katz sobre como ele usa o GIT e me empolguei para escrever também.

Antes de mais nada, gostaria de dar os devidos créditos ao @rogerio_augusto porque foi ele quem me ensinou boa parte dos itens que vou escrever hoje.

Pull e Push

Bom, vou começar pelo mais básico, enviar e receber commits do repositório remoto.

Geralmente o pessoal acredita que a fórmula é essa:

commito alguma coisa
faço pull para ver se tem alguma coisa no remoto
faço push para enviar para ele

Isso até que funciona, mas eu prefiro uma outra abordagem que deixa a árvore dos commits mais organizada.

O pull nada mais é do que um fetch (baixa objetos e referências do remoto) mais merge (junta duas ou mais histórias).

Imagine que você baixou tudo que estava no remoto e fez um commit. Enquanto você trabalhava outra pessoa enviou alguma coisa para o remoto que você não tem. Se você fizer um pull, a árvore dos commits ficará assim:

Para não ter que criar um repositório remoto para o exemplo, eu fiz o merge entre dois repositórios locais, mas o resultado é o mesmo.

Com o merge ele mostra que os commits foram feitos em paralelo, mas as vezes essa informação não é tão relevante, e vale mais a pena deixar a árvore organizada. Por isso quando eu vou fazer isso, ao invés de eu dar um pull pro remoto, eu faço um rebase. Por exemplo:

git fetch

git rebase origin/master

Ou, mais fácil de usar

git pull --rebase origin master

Com o rebase o git faz um stash de seus commits que ainda não existem no remoto, baixa os branchs do remoto e recoloca seus commits após o que veio dele. Ficaria assim:

Viram? O git passou o seu commit para depois dos commits que vieram do repositório (apesar deles poderem ter ocorrido antes) e assim manteve a árvore organizada e fácil de entender.

Tem gente que fala que assim você perde a real história dos commits, mas eu discordo. Para casos em que a história é relevante eu uso o pull normal para deixar registrado o que aconteceu (por exemplo, estou criando uma aplicação a partir de uma outra open source e a original foi atualizada, aí sim eu faço um pull para mostrar que são commits de equipes diferentes que andaram em paralelo), mas para os casos de commits dentro da mesma equipe trabalhando numa mesma tarefa, acho que vale mais a árvore se manter legível.

Merge com a opção squash

Geralmente eu uso branchs para separar as histórias do projeto que estão sendo criadas, sendo assim, imagine a seguinte situação:

Você criou um branch a partir do master para fazer sua história. Nesse seu branch você fez 23 commits, que foram totalmente úteis para você se organizar, integrar mais facilmente, etc.

Então você terminou sua história e vai fazer o merge para mandar sua nova funcionalidade para o remoto, então você faz:

git checkout master

git pull origin master (imaginando que você não commitou nada no seu master, senão o mais correto é git pull --rebase)

git checkout seu_branch

git rebase master

git checkout master

git merge seu_branch

git push origin master

Com isso você atualizou seu master, integrou as atualizações do master com o seu branch, fez o merge do seu branch no master e aí sim enviou os seus 23 commits.

Até aí você fez tudo perfeitamente, mas existe uma outra ferramenta que pode te ajudar a se organizar, a opção --squash do merge.

Quando você faz o merge com --squash (git merge seu_branch --squash) o git leva as atualizações pro seu branch mas como se elas não tivessem sido commitadas. Aí você faz um único commit e manda só ele para o master.

Para quem está olhando o master, faz mais sentido ver um commit por funcionalidade, enquanto para quem está desenvolvendo a funcionalidade os 23 commits são úteis. Então agindo assim a gente ajuda todo mundo. Ficaria assim:

git checkout master

git pull origin master

git checkout seu_branch

git rebase master

git checkout master

git merge seu_branch --squash

git add .

git commit -am "Minha funcionalidade"

git push origin master

Opção stash do git merge

Uma outra ferramenta útil é o stash. Imagine que você vai fazer uma atualização pequena no seu projeto e resolveu fazer no branch master mesmo (para aplicações que dividem o projeto em dois remotos - produção e desenvolvimento - eu acho isso totalmente normal). Só que enquanto você está fazendo você percebe que será uma atualização grande e seria mais interessante fazer isso num branch a parte (ou alguém te chamou para fazer outra coisa e você não vai poder continuar aquilo no momento). Então você está com algumas modificações sem commitar mas você não vai poder commitar no master, porque não está concluído, etc.

Para isso você pode usar o stash, você faria assim:

git stash (o git guarda todas as suas modificações em um lugar a parte e seu branch atual passa a ficar como se ninguém tivesse mexido - você pode usar git status para confirmar)

git checkout -b seu_branch_novo

git stash apply (suas modificações voltam a aparecer, pode confirmar com git status)

git commit -am "Primeiro commit da minha funcionalidade"

git stash clear (apaga tudo o que estava no stash)

git checkout master

Com isso você fez como se tivesse começado desde o início em um branch novo.

Você consegue também criar e gerenciar mais de um stash, mas geralmente um só satisfaz minha necessidade.

Opção track do git branch

Vamos a mais uma situação. Seu colega começou uma funcionalidade em um branch a parte e depois de alguns dias pediu para você ajudar ele nessa tarefa.

Você tem que trabalhar nesse mesmo branch dele, então você decide criar o branch dele localmente. Você faz:

git branch branch_dele

git checkout branch_dele (você poderia ter usado git checkout -b branch_dele e fazer tudo de uma vez)

git pull origin branch_dele

CUIDADO!

Quando você fez o primeiro comando você criou um novo branch a partir do que você tem em seu branch atual. E pode ser que você tem coisas nele que não deveriam estar no branch do seu colega, pode ser até conflitante com as tarefas dele e além disso o merge vai bagunçar legal a árvore dele. Se você fizer um rebase pode até piorar mais porque você terá que dar um --force para reescrever a história dele e ele terá que se atualizar. Bom, enfim, essa situação pode gerar resultados não esperados.

Para isso o mais indicado seria:

git fetch

git branch branch_dele --track origin/branch_dele

git checkout branch_dele

Com a opção --track o git vai criar o branch a partir do que tem no brach remoto que você informou, sem olhar para o que tem no seu branch atual. Sendo assim você ficará com o branch idêntico ao do seu colega, o que é o ideal para essa situação.

O git fetch antes é importante porque o --squash vai criar o branch com as informações que estiverem no repositório local, não no remoto. Faça o fetch para atualizar o repositório local antes.

Voltando commits

Outra coisa útil é conseguir voltar atrás em algo que está fazendo. Por exemplo:

Você começou uma tarefa e percebe que está indo na direção errada e deseja começar de novo.

Se você ainda não fez nenhum commit basta usar:

git reset --hard

E você voltará ao estado do último commit efetuado.

Se você já tinha commitado algo, então você pode fazer:

git reset --hard id_do_seu_commit

Exemplo:

git reset --hard dbeeeb0369b5bad0f776fc5ae16c5500bd808156

Com o reset você consegue ir para trás e para frente. Para pegar o id de um commit que está a frente você pode usar:

git reflog

Acabou

Bom, tentei lembrar de algumas situações que são comuns em um projeto. Espero ter ajudado e gostaria da opinião de vocês. Pode ser que existam outras abordagens melhores, então estou aberto para discutir e aprender.

Qualquer dúvida podem entrar em contato comigo (comentário, gtalk, twitter, email etc).

Abraços.

Usando nested attributes com single table inheritance

2010-05-01T11:06:00.004-03:00

Esses dias no serviço precisamos usar single table inheritance em alguns models do nosso projeto.

Por exemplo, eu tenho a classe:

E duas outras que herdam dela:

Esses models utilizam a mesma tabela no banco de dados (questions) que contém uma coluna "type" que diz se a questão é uma MultipleChoiceQuestion ou é uma SingleChoiceQuestion.

O problema é que ao usar esses models em um formulário aninhado com accepts_nested_attributes, por mais que eu colocasse um hidden_field dizendo qual era o type da question, o Rails não salvava ele (o campo ficava nulo no banco).

Procurando pela internet encontrei uma solução que achei interessante e resolveu meu problema. Foi uma resposta que o KandadaBoggu deu no fórum stackoverflow.

O atributo type é protegido por padrão em classes que herdam de ActiveRecord::Base, para solucionar o problema podemos sobrescrever o método que define isso na nossa classe question:

Gem donald versão 0.1.4

2010-04-25T19:55:00.004-03:00

Ontem a noite lancei mais uma versão da gem Donald, dessa vez consegui adicionar algumas features novas.

Donald é uma gem que eu fiz para tratar conflitos do GIT, quando o conflito ocorre você executa o comando "donald" e ela abre os arquivos conflitados no seu editor de texto favorito (no início ela foi desenvolvida para o vim, mas aí abri espaço para outros editores).

Novas features:

Abrir arquivos no vim já procurando por conflitos: agora quando você estiver usando o vim (mvim e gvim também) a gem já abrirá os arquivos fazendo uma busca por "HEAD", que é um texto comum a todos os conflitos. Sendo assim basta apertar "n" para ir para o próximo conflito.

Configurar seu editor padrão: agora você pode configurar o editor de textos que mais usa (se não for o vim) para que o Donald utilize ele por padrão sem ser necessário passar nenhum parâmetro adicional. Para isso basta configurar a variável padrão $EDITOR em seu sistema.

Um jeito de fazer isso é adicionar a seguinte linha ao arquivo ~/.bashrc

export EDITOR="mate"

Isso é um exemplo para configurar o textmate como o editor padrão. Você pode até configurar um editor que a gem não cobre, como o gedit, por exemplo.

Para maiores informações visitem o repositório do projeto.

Para atualizar sua gem execute:

sudo gem update donald

Abraços.

Gem donald versão 0.1.3

2010-04-21T20:31:00.003-03:00

Lancei hoje uma nova atualização para a gem donald.

Para atualizar execute:

sudo gem update donald

Havia uma situação do git que ela não cobria (both modified). E diga-se de passagem é uma situação bem comum.

Fiz essa correção hoje e estou disponibilizando, para quem usa ela é bem interessante fazer o update.

Obrigado @julioavero por reportar e @raulsouzalima por me mandar o exemplo.

Tem algumas novas funcionalidades que pretendo adicionar à gem, como criar um arquivo de configuração para configurar seu editor padrão (e assim você conseguiria configurar qualquer editor, como o gedit por exemplo). Assim que sobrar um tempinho vou mecher nela.

Se alguém quiser adicionar qualquer funcionalidade nela ou bug fix sinta-se livre, o código fonte está em:

http://github.com/BrunoGrasselli/donald

Basta fazer um fork e depois me mandar um pull request (os testes tem que continuar passando =) )

Abraços.

Nova gem Params Debugger

2010-04-11T16:25:00.002-03:00

Acabo de lançar uma nova ruby gem para me ajudar no desenvolvimento de meus projetos e acredito que possa ajudar também outras pessoas em aplicações Rails.

É uma gem bem simples, por exemplo:

Você está criando um formulário e deseja ver o que ele está passando por parâmetro para o Rails, com a gem instalada você faz assim:

params_debugger create

(Aonde create é a action do controller que eu estou debugando)

Fazendo isso ele vai imprimir no terminal a última linha do log de desenvolvimento que ele achar de parâmetros para essa action, já formatada para uma melhor visualização.

Você pode usar também a opção -p para exibir sem formatação (plain):

params_debugger -p update

Ou até passar mais de uma action:

params_debugger -p create update

Para instalar a gem basta fazer:

sudo gem install params_debugger

Código fonte:

http://github.com/BrunoGrasselli/params_debugger

Bom é isso, aguardo seus comentários.

Abraços.

Gem donald atualizada

2010-04-03T17:48:00.003-03:00

Fala pessoal,

Hoje atualizei minha gem donald.

Eu criei essa gem para facilitar na resolução de conflitos do git. Executando o comando "donald" quando os conflitos acontecem ela abre todos os arquivos conflitados no vim, um em cada aba.

Agora nessa atualização ela também tem suporte ao Textmate usando as opções -t ou --textmate (e agora ela está coberta por testes).

Mais informações em:

http://github.com/BrunoGrasselli/donald

Se você já tinha ela e quer atualizar:

sudo gem update donald

Se ainda não tinha:

sudo gem install donald

Abraços.

Teclado Vim

2010-04-01T17:43:00.004-03:00

Fala pessoal,

Ultimamente estou viciado em vim / vi e hoje vi uma dica que o Rafael O. Marques mandou para o grupo do GURU-SP que eu achei muito legal, vim aqui repassar.

Segue imagem do teclado do vim (vi / vim graphical cheat sheet), clique para ampliá-la.

Espero que seja útil, abraços.

Alguns comandos úteis do Vim

2010-03-20T19:34:00.003-03:00

Gostaria de compartilhar alguns comandos úteis que utilizo no vim no meu dia a dia. Até tentei ir pro Textmate mas não adiantou, voltei para o vim.

Bom, vamos lá, no modo normal:

dd - Exclui a linha atual inteira
D - Exclui a partir do caractere atual até o final da linha
C - Exclui a partir do caractere atual até o final da linha e entra em modo de inserção
ci" - Quando executado dentro de um texto entre aspas, exclui tudo que está dentro das aspas e entra em modo inserção (funciona também com ' { [ etc)
ct" - Exclui texto até a próxima aspa e entra em modo inserção (funciona também com ' { [ etc)
V - Seleciona linha inteira
ddp - Substitui duas linhas
xp - Substitui duas letras (não tão útil)
dw - Exclui próxima palavra
cw - Exclui próxima palavra e entra em modo inserção
s - Exclui caractere atual e entra em modo inserção

Em modo visual:

c - Exclui texto selecionado e entra em modo inserção

Em modo de comando:

:!qualquer_comando_de_terminal - Executa qualquer comando do terminal, por exemplo :!ls ou :!rake db:migrate

Pra quem tem rails.vim (bem similares aos do Textmate):

def + tab - Facilita criação de bloco
vpo + tab - validates_presence_of
vu + tab - validates_uniqueness_of
conf + tab - content_for
habtm + tab - has_and_belongs_to_many
it + tab - teste do rspec

Bom espero que as dicas ajudem, se você souber alguma legal estou interessado em aprender, manda via comentário, e-mail, etc.

Abraços.

Donald - Gem para auxiliar a resolver conflitos do GIT com o Vim

2010-03-20T18:43:00.007-03:00

Lá na empresa estamos experimentando trabalhar com integração contínua (e está apresentando ótimos resultados até agora) o que, como o nome sugere, faz com que a gente tenha que fazer mais rebases diários com o git. O que as vezes pode resultar em alguns conflitos.

Com o passar do tempo os conflitos estão diminuindo usando algumas técnicas que estamos aprendendo, e fazendo a integração cada vez mais constante.

Mas de um jeito ou de outro sempre acontece algum conflito no git para resolver e eu não sou muito fã de usar merge tools, prefiro corrigir com um editor de textos qualquer (no meu caso o vim). A única parte chata disso é abrir todos os arquivos conflitados um a um.

Para resolver isso eu fiz uma pequena gem que auxilia na solução de conflitos de uma forma muito simples. Assim que ocorrem os conflitos basta invocar a gem que ela abre todos os arquivos do conflito de uma vez no vim, um em cada aba.

A gem se chama Donald (eu estava sem criatividade pra pensar num nome e dei qualquer um =P) e funciona da seguinte forma:

Instalação:

sudo gem install donald

Quando acontecer o conflito, basta digitar:

donald

E o vim será aberto com todos os arquivos em abas.

Bom é isso, fiz essa gem rapidinho pra tentar me auxiliar la no serviço (eu realmente acredito que vai ajudar). Essa foi minha primeira gem, então se tiverem dicas serão bem vindas.

Se tiver ideias também você pode ajudar fazendo um fork do meu projeto que está em:

http://github.com/BrunoGrasselli/donald

E a gem está hospedada em:

http://rubygems.org/gems/donald

Pretendo adicionar algumas funcionalidades nela como abrir o gvim e mvim ao invés do vim, e talvez até outros editores (preciso escrever testes também).

Abraços.

Ps. Atualizei a gem hoje (21/03/2010) e ela já tem as opções de abrir com o gvim ou mvim (--mvim, --gvim ou -m, -g).

Rails 3.0 Beta lançado!

2010-02-07T13:40:00.005-02:00

Dia 05/02/2010 foi lançada a nova versão do Rails, 3.0, ainda beta.

Se você deseja experimentar, instale dessa forma:

sudo gem install tzinfo builder memcache-client rack rack-test rack-mount erubis mail text-format thor bundler i18n
sudo gem install rails --pre

Fiz alguns testes agora a pouco e logo de cara já da pra perceber algumas das muitas diferenças. Algumas pequenas diferenças que que já dá pra se perceber só de gerar um scaffold:

Comandos como script/generate e todos os outros que ficavam dentro da pasta script agora são executados a partir do comando rails. Por exemplo:

rails g scaffold user name:string last_name:string
rails server

E o output desses comandos no terminal agora aparecem coloridos.

As gems que o projeto utiliza agora são listadas num arquivo Gemfile na pasta raiz, não mais no environment.rb.

Existe também um objeto da aplicação que é configurado em config/application.rb

As mudanças são muitas, essas são só algumas pequenas que eu percebi ao gerar um scaffold. Mais detalhes você pode ver em:

http://weblog.rubyonrails.org/2010/2/5/rails-3-0-beta-release

Ou no post traduzido pelo Akita:

http://www.akitaonrails.com/2010/02/02/h2-anotacoes-de-lancamento-ruby-on-rails-3-0

Aqui tem um screencast gratuito mostrando como converter uma aplicação do Rails 2.3.5 para 3.0:

http://blog.peepcode.com/tutorials/2010/live-coding-rails-3-upgrade

Acredito que a próxima etapa agora é migrar as gems e plugins das versões antigas para as novas, para aí sim podermos criar aplicações nessa nova versão.

Foi criado também um site para listar as gems que já estão funcionando, você pode encontrar em:

http://railsplugins.org

É isso pessoal, até o próximo post!

Como executar o cucumber em português

2010-01-29T23:58:00.003-02:00

Uma grande característica do cucumber é que você pode criar seus testes na sua lingua nativa, facilitando ainda mais o processo e a integração com o cliente.

Recentemente o cucumber mudou a forma de se rodar as features em outra lingua, então vim aqui postar como ficou na nova versão (a partir da versão 0.5.0).

Primeiramente, para listar os idiomas que o cucumber suporta, basta digitar o comando:

Para nosso exemplo, vamos configurar ele em português.

O cucumber trabalha com um arquivo chamado web_steps.rb (que antes se chamava webrat steps) que trás os steps mais utilizados já configurados. Você pode traduzir esse arquivo do modo que preferir para o português, ou utilizar a versão já traduzida pelo pessoal do cucumber, gerando-o com o comando que configura o cucumber no Rails dessa forma:

Com isso você terá um arquivo chamado features/step_definitions/web_steps_pt-BR.rb

Antes para executar as features em português você tinha que passar a linguagem para o cucumber através do parâmetro -language. Hoje esse parâmetro não existe mais, e para configurar sua feature em português basta adicionar a seguinte linha no começo do arquivo:

A partir daí você já pode criar suas features em português, um exemplo:

Para listar as palavras chaves do cucumber em português você pode digitar:

Bom, espero ter ajudado.

Até o próximo post!

Counter cache, Ruby on Rails

2010-01-23T12:39:00.003-02:00

Um recurso interessante do Rails para otimização de desempenho é o counter_cache.

Por exemplo, na página inicial de uma aplicação que estou trabalhando nós exibimos uma lista de eventos, e cada um desses eventos tem um ou mais orçamentos (Event has_many :budgets).

Nós temos que exibir numa coluna a quantidade de orçamentos existentes desses eventos. Para isso uma solução seria fazer um SELECT COUNT para cada evento (listamos 30 eventos por página, então seriam 30 consultas) ou poderíamos fazer um SQL mais elaborado no começo para consultar já com os counters, o que poderia sair um pouco do padrão ou até complicar um pouco o código.

Para solucionar meu problema eu acionei a opção de counter_cache no relacionamento belongs_to da minha classe Budget:

Sendo assim, o Active Record entende que existe um campo chamado budgets_count na tabela events, que ele atualiza toda vez que eu adiciono ou removo um orçamento de um evento.

Na hora de listar os eventos na página inicial, ao invés de fazer um SELECT para cada um dos eventos, eu vou direto nesse contador gerado pelo Active Record.

O desempenho fica muito melhor porque eu visualizo muito mais a página inicial do que cadastro orçamentos, então vale mais a pena deixar o Rails atualizar esse número na hora do cadastro, do que fazer essa conta toda vez que eu exibo. Além disso, para o Rails atualizar esse contador não demanda muito processamento, uma vez que ele não calcula efetivamente quantos itens tem toda hora que eu salvo, e sim incrementa ou decrementa o contador a partir do número atual.

Como fazer

Vou explicar passo a passo como configurar. Vamos criar um exemplo aonde eu tenho a classe Album e a classe Picture. E um album tem muitas pictures.

Primeiramente, vamos configurar nossa classe Picture para dizer que o relacionamento belongs_to dela em relação a Album deve ter counter_cache.

O model de Picture ficaria assim:

E o model Album:

Quando colocamos a opção counter_cache como true, o Active Record entende que na tabela albums existirá uma coluna com o nome pictures_count (nome da tabela + '_count'). Se você quiser utilizar um campo com um nome diferente, basta informar no lugar do true, exemplo: :counter_cache => 'my_custom_counter'

Agora temos de criar o campo na tabela albums. Vamos fazer uma migração para adicionar esse campo (caso o modelo já exista):

Com o comando acima a migração será gerada quase pronta, você só precisará adicionar :default => 0 no campo pictures_count, deve ficar assim:

Agora vamos testar para ver se funciona. Segue abaixo alguns comandos que executei no terminal para criar um álbum com duas fotografias:

Agora vamos analisar o SQL gerado para esses comandos:

Ele consultou o banco para buscar as colunas de Album e Picture, depois fez os INSERTS e UPDATES para atualizar os contadores. Mas no final, quando solicitei solicitei a quantidade de fotografias do último álbum, ele apenas buscou o álbum mas não precisou fazer um SELECT COUNT para saber quantas tinhas, ele utilizou o cache.

Se o cache não existisse, você veria também o SQL abaixo:

Pode parecer pouco, mas numa página que é muito requisitada, e que exibe muitos registros, pode fazer diferença. Principalmente em épocas de servidor congestionado.

Existem algumas outras formas interessantes de cache que o Rails oferece, como o cache de página, de action, de fragmento, de SQL, entre outros.

Você pode ler a respeito deles em:

http://guides.rubyonrails.org/caching_with_rails.html

Talvez mais pra frente eu fale de outros caches aqui no Blog.

Bom, é isso pessoal, espero ter ajudado. Qualquer dúvida ou opiniões podem postar comentários ou entrar em contato comigo através de e-mail, twitter, gtalk, etc.

Abraços e até o próximo post.

Associações polimórficas com Ruby on Rails

2009-12-06T19:13:00.010-02:00

Hoje vou falar de um recurso que utilizei bastante nos últimos dias nos projetos que estou envolvido e acredito que seja útil para muitos.

O polimorfismo é uma características que existe em muitas linguagens orientadas a objetos, quando falamos de uma associação polimórfica, estamos dizendo que um objeto tem um outro objeto (ou mais), e esse outro objeto pode ser de várias formas (classes) diferentes.

Por exemplo:

Um objeto do tipo Tabuleiro (xadrez) tem muitas Peças, e essas peças podem ser de várias classes diferentes (Peão, Bispo, Torre, etc...).

Um exemplo na prática, digamos que existe a classe BankAccount (conta corrente) em sua aplicação Rails.

Essa BankAccount pertence a alguém, mas esse alguém pode ser um fornecedor (Supplier), um cliente (Customer) ou até mesmo um usuário (User).

Para lidarmos com esse tipo de situação no Ruby e persistir essas informações no banco de dados em uma aplicação Rails, podemos fazer da seguinte forma:

Primeiro passo: Definir um nome para essa associação

Nossa conta corrente pertence a qualquer objeto apto a ter uma conta corrente, vou chamar esse tipo de objeto de "accountable".

Segundo passo: Criar as colunas no banco de dados

Temos que criar duas colunas no banco de dados, uma que registrará o tipo do objeto (nome da classe) e outra o id do objeto.

Para criar essas colunas em uma migração, basta escrevermos assim:

Como visto na linha 9, a síntaxe é:

t.references :accountable, :polymorphic => true

Ou você pode criar manualmente duas colunas, uma com o nome da associação mais "_id" do tipo integer, e outra com o nome + "_type" do tipo string, como no exemplo:

Terceiro passo: configurar a classe BankAccount

Para definir a associação na classe BankAccount, fazemos assim:

Como visto na imagem:

belongs_to :accountable, :polymorphic => true

Quarto passo: configurar as classes que possuirão contas corrente

Para fazer isso, basta definirmos a associação nas classes que desejamos que possuam contas corrente, por exemplo, na classe Supplier:

Como mostrado na imagem, para definir a associação:

has_many :bank_accounts, :as => :accountable

Último passo: Utilizar onde for preciso

Uma vez configurada, para utilizar é muito simples, por exemplo, para dizer a uma conta que ela pertence a um usuário:

account.accountable = user

(supondo que a variável user está carregada com um objeto do tipo User)

Digamos que a conta pertence a um Supplier, e você deseja ver a razão social desse fornecedor:

account.accountable.corporate_name

Você pode também, a partir do objeto user ou qualquer outro objeto que possua a associação, recuperar um array de contas a partir de:

user.bank_accounts

Concluindo

Você pode estudar mais a respeito desse tipo de associação no Rails Guide.

Espero ter ajudado, qualquer dúvida pode postar um comentário ou entrar em contato via twitter, gtalk, e-mail, etc.

Navegadores que acessam o blog

2009-11-22T18:59:00.003-02:00

Acredito que esse tipo de informação é importante para nós que desenvolvemos para a internet, seria interessante se todos compartilhássemos esse tipo de estatísticas.

O gráfico abaixo mostra as visitas da última semana do blog por navegadores (clique na imagem para ampliá-la).

Para minha felicidade, o blog é mais acessado por usuários com Firefox (66,09%), mas isso só é possível porque o blog tem um público específico, na sua grande maioria formado por desenvolvedores web, que estão mais do que cansados de saber que Internet Explorer é um lixo.

Em sites com público variado que tenho acesso às estatísticas, a maioria ainda usa Internet Explorer, e o que é pior, muitas vezes na versão 6.

Um dia ainda conseguiremos inverter essa estatística, para o nosso bem (desenvolvedores) e para um melhor proveito da internet pelos usuários, e com mais segurança.

Método toggle() do Jquery com problemas no IE8

2009-11-05T21:44:00.004-02:00

Esses dias tive que usar algumas soluções em javascript, mais especificamente Jquery, pra atender a uma necessidade em nosso projeto.

Depois da página feita fui testar em outros navegadores (eu crio primeiro no Firefox) e uma funcionalidade simples, que é o método toggle() do Jquery (utilizado pra esconder / exibir um elemento), havia parado de funcionar somente no IE8, até no IE6 funcionava, mas no 8 não.

O mais estranho era que a versão anterior dessa página utilizava o toggle e ele funcionava no IE8, por que então parou de funcionar?

O problema.

Depois de analisar bem o código percebi que a única diferença era que eu tinha trocado o elemento em qual eu invocava o toggle. Antes era uma DIV e depois eu troquei para uma TR.

Foi então que eu descobri, através desse tópico aqui (http://stackoverflow.com/questions/975153/jquery-toggle-not-working-with-trs-in-ie) que o toggle do Jquery não funciona bem no IE8. Ele esconde a primeira vez, mas após isso ele não consegue mais exibir. No meu caso como já vinha escondido quando a página era carregada, ele nunca aparecia.

A solução.

Parece que o problema acontece devido a forma que o Jquery valida se o TR está escondido ou não, que retorna sempre true, falando que ele está visível.

Para solucionar o problema eu escrevi um método (ou função), que faz praticamente a mesma coisa que o toggle, só que verificando de outra forma, ficou assim (na verdade a ideia do método foi do Brian Bolton, naquele tópico que mencionei, eu apenas adaptei para funcionar com id's, que ficava melhor para o que eu precisava):

Utilizando essa função funcionou bem em todos os navegadores que testei.

Na verdade, se você habilitar a opção do IE8 de suporte a navegadores antigos funciona com o toggle simples, mas não podemos exigir que nossos clientes usem.

Enfim, mais uma vez isso só aumentou meu desejo de que o Internet Explorer sumisse de vez da internet, mas...

Espero que o post ajude quem estiver passando pelo mesmo problema.

Abraços.

Claro 3g no Mac OS X

2009-11-04T23:17:00.003-02:00

Há um ou dois meses atrás eu tomei coragem e comprei meu primeiro Mac, um Macbook branco, infelizmente ainda no formato antigo, o novo saiu um mês depois da compra, mais barato do que eu paguei. Mas tudo bem, detalhes a parte, se você está na mesma dúvida que eu tinha se vale ou não a pena comprar um Mac, aceite minha dica, vale sim muito a pena, eu deveria ter comprado antes.

No laptop antigo eu usava Claro 3g, com o modem Huawei E226, para quando eu estava em algum lugar que não tinha wireless (se você está procurando uma operadora de internet móvel, não escolha a Claro. A internet vai ficar super lenta após alguns meses e você nunca vai conseguir ser atendido por eles no telefone).

Enfim, como ainda tenho mais alguns meses pra pagar antes de poder encerrar o contrato, eu queria que o Claro 3g funcionasse no meu Mac.

Procurando em alguns blogs li que a Claro era a única até o momento que oferecia suporte ao Mac OS X (apesar deles nunca atenderem minhas ligações para prestarem esse suporte), e encontrei um monte de programas, que supostamente eram os drivers, mas nenhum funcionou.

Hoje resolvi tentar de novo e dessa vez eu consegui, por isso vim aqui dizer para você como.

No link abaixo eu consegui fazer o download do driver que funciona:

http://blog.evandavey.com/2008/02/how-to-connect-huawei-e220-usb-modem.html

Detalhe que dentro do zip possui dois arquivos, o que você deve usar é o segundo, com o nome:

HuaweiDataCardDriver(2.6)-intel

Para instalar basta dar dois cliques e ficar apertando em "próximo".

Depois de instalar conecte seu modem. No meu caso ele mesmo disse que havia uma nova conexão e pediu para configurar, mas se isso não aconteceu para você, entre em:

Preferências do sistema -> Rede

Se o dispositivo HUAWEI mobile não apareceu para você na lista a esquerda, clique no botão com um sinal de + (mais) la em baixo para adicionar, selecione a interface Huawei mobile e de um nome para ela.

Após adicionado basta configurar e por para funcionar, os dados para configuração são:

Configuração: Padrão
Telefone: *99***1#
Nome da conta: claro
Senha: claro

Informações retiradas de:
http://macmagazine.uol.com.br/2008/01/18/dica-como-configurar-o-modem-huawei-e226-da-claro-3g-no-leopard

Você pode também selecionar a opção: "Mostrar o estado do modem na barra de menus".

Com isso já deve começar a funcionar!

Espero que a dica ajude, no meu caso funcionou no Mac OS X Snow Leopard também.

Abraços e até o próximo post.

Dev in Sampa

2009-11-01T21:32:00.003-02:00

Pessoal, post rápido para ajudar a divulgar uma nova iniciativa de evento da comunidade de desenvolvedores de são paulo, o Dev in Sampa.

Informações:

O que é?

É o primeiro encontro de desenvolvedores de software em São Paulo, onde serão ministradas palestras voltados a desenvolvimento, arquitetura e engenharia de software.

Quando?

Será realizado dia 28/11 (sábado), das 9:00 às 18:00.

Onde?

Editora Abril S/A - Auditório

Av. das Nações Unidas, 7221 - Alto de Pinheiros - São Paulo, SP, 05425-070

Para mais informações visitem: http://www.devinsampa.com.br

Eu vou!

Trabalhando com abas no VIM

2009-10-11T16:21:00.003-03:00

Recentemente comecei a tentar usar o Textmate, mas ainda não consegui abandonar o Vim. Uma coisa que vi no Textmate que eu queria que tivesse no Vim são as abas.

Mas o que eu descobri esses dias é que o Vim trabalha com abas também, a partir da versão 7 (eu não sabia disso).

Se você também não sabia, seguem alguns comandos para trabalhar com as abas:

:tabnew
Abre uma nova aba

:tabn número
Navega entre as abas, exemplo:
tab 2 (vai para a aba número 2)

:tabnext
Vai para a próxima aba

:tabprev
Vai para a aba anterior

:tabfirst
Vai para a primeira aba

:tablast
Vai para a última aba

E se você usa rails-vim e está acostumado com comandos como :RSmodel, RVcontroller, etc, você pode utilizar também a versão desses comandos com T, exemplo:

:RTmodel
Abre um model numa nova aba

:RTview
Abre uma view numa nova aba

:RTcontroller
Abre um controller numa nova aba

:AT
Abre o teste numa nova aba

Uma coisa que aconteceu comigo usando abas no gvim + Ubuntu foi que quando eu abri as abas (com o gvim maximizado) a linha de comando do vim sumiu. Se isso aconteceu com você também basta restaurar e maximizar o vim novamente.

Criando rake tasks

2009-10-10T19:07:00.009-03:00

Um ótimo jeito de criar um script Ruby para sua aplicação Rails, principalmente se ele precisar ter o ambiente do Rails carregado, é através de rake tasks.

Quando eu ouvia falar de criar rake tasks eu achava que devia ser algo complexo, mas esses dias precisei criar um script Ruby para popular o banco de minha aplicação e o Cassio Marques me falou pra dar uma olhada nesse tipo de arquivo, me impressionei com o quão simples é criar uma.

Para criar uma rake task crie um arquivo com a extensão .rake dentro do diretório lib/tasks de sua aplicação. Exemplo:

lib/tasks/example.rake

Dentro do arquivo abra um bloco como o do exemplo:

Dentro desse bloco você pode escrever script Ruby, por exemplo:

A partir daí você já pode executar:

rake my_new_rake_task

O resultado será:

$ rake my_new_rake_task
(in /Users/bruno/projetos/scafold)
Hello

Você pode também adicionar uma descrição para ela, assim ela aparecerá na lista de taks do rake:

Para ver a sua task na lista execute o comando:

rake -T

Ou, para achar ela de uma forma mais fácil:

rake -T | grep new

Como resultado, dentre a lista que aparecer você encontrará:

rake my_new_rake_task # Just an example

Caso você precise do ambiente Rails carregado para executar o seu script, na hora de abrir o bloco faça da seguinte forma:

task :name => :environment do

Como no exemplo:

Você pode criar mais de uma task por arquivo:

Bom é isso pessoal, a partir daí basta utilizar o poder do Ruby e do Rails para criar as mais diversas tarefas.

Espero que o post ajude e até o próximo.

Problema ao renderizar view no formato XLS no Internet Explorer

2009-10-02T21:49:00.005-03:00

Saudações pessoal,

Já faz um tempo que eu não posto nada, o último mês foi bem corrido, comecei em um novo emprego (dessa vez com Ruby on Rails), além das provas na faculdade, entre outros. Mas estou cheio de assuntos novos para tratar no blog.

Antes de mais nada queria parabenizar o pessoal do GURU-SP que fez mais um excelente evento no final de semana passado, cheio de gente e com o conteúdo muito interessante (testes). Se você ainda não participa do grupo não deixe de dar uma olhada.

Hoje gostaria de falar pra vocês a respeito de um problema muito estranho que tive para renderizar arquivos xls (Excel) no serviço.

Fizemos uma reelaboração do módulo de relatórios de nossa aplicação recentemente e nesse novo modelo é possível visualizar um relatório nos formatos: html, pdf e xls.

Testamos no nosso ambiente de desenvolvimento (Linux ou Mac OS X com Firefox) e tudo parecia correr tudo bem.

Para fazer com que sua aplicação renderize views no formato do Excel é bem simples, basta adicionar no arquivo config/initializers/mime_types.rb a linha:

Mime::Type.register "application/vnd.ms-excel", :xls

E na hora de renderizar no controller:

Aí basta criar o arquivo com o nome no formato:

nome_da_action.xls.rb

Nesse arquivo você pode escrever uma tabela no formato html, ou até mesmo criar um arquivo no formato xml, como o Ary Djmal mostra nesse post:

http://arydjmal.com/2008/6/8/export-to-excel-in-rails-2

Hoje, com a aplicação em produção, descobrimos que o Internet Explorer apresenta um comportamento completamente estranho em relação a esse tipo de tratamento.

Quando clicavam no link para exibir a página no formato html, por algum motivo estranho o IE tentava sempre renderizar o formato xls ao invés do html.

Para resolver esse problema utilizamos a solução sugerida pelo Ary Djmal no link que mencionei acima (thank you man), que foi adicionar a seguinte condição na hora de renderizar:

Dessa forma funciona no IE e continua funcionando nos outros navegadores.

Como a informação foi muito útil para mim, resolvi passar ela adiante pra quem passar pelo mesmo problema.

Não sei por que ele acontece, se alguêm souber estou muito interessado em saber.

No mais, isso só aumenta meu desprezo pelo Internet Explorer.

Espero que o post ajude, tenho mais alguns assuntos interessantes que gostaria de escrever mas exigem um pouco mais de tempo, vou tentar escrever esse final de semana.

Abraços.

Saber, dentro de um helper, o nome da view que o invocou

2009-08-09T18:10:00.003-03:00

Esses dias eu estava querendo criar um helper para me ajudar com o I18n (Internationalization) da minha aplicação.

O problema é que dentro desse helper, eu precisava saber o nome da view que o invocou.

Geralmente nós usamos params[:controller] e params[:action] para saber o nome do controller e da action, respectivamente. Para saber o nome da view, as vezes é usado a constante __FILE__, mas nesse caso ela não ajuda porque se você usá-la dentro de um helper ela te retornará o nome do arquivo do helper, e não da view que o invocou.

Postei a pergunta no grupo da rails-br e o Rafael Rosa descobriu a solução pra mim (através desse link). Para conseguir o nome da view, você pode usar um desses métodos:

@template.template.relative_path
@template.template.base_path
@template.template.filename
@template.template.path_without_format_and_extension
@template.template.path_without_extension
@template.template.source

Acredito que os nomes são auto explicativos.

Como a dica foi útil para mim, resolvi publicar aqui para caso mais alguém estiver com esse problema.

Abraços, e até o próximo post!

Indentar linhas no VIM

2009-08-08T14:52:00.002-03:00

Há alguns meses escolhi o vim como meu editor de textos para trabalhar com Rails. Ainda sou um usuário novo de vim, e sempre acabo aprendendo um ou outro comando novo com ele.

Nunca soube como fazer para indentar as linhas nele, aí hoje tomei vergonha na cara e fui procurar no google um comando para isso. O comando é muito simples, e também muito útil.

Para indentar uma linha, basta posicionar o cursor sobre a linha desejada, em modo de comando (ESC) digitar:

==

Se você quer, por exemplo, indentar as próximas 5 linhas, pode usar:

5=

Ou o número de linhas que desejar.

Com == e 5= ele indenta de acordo com o código e a indentação anterior.

Se você deseja simplesmente indentar a linha atual pra frente ou para trás, independente de código, pode usar também:

>>

e

<<

Bom é isso pessoal, espero que a dica ajude.

Pretendo fazer um post depois sobre os comandos que mais utilizo no vim. Se você indenta no vim de algum outra forma, ou se tem algum comando que você usa com frequência e acha útil fique a vontade para postar um comentário e contribuir com o post.

Abraços!

Enviar parâmetros para um partial

2009-08-05T22:03:00.008-03:00

Essa é uma dica simples, mas que tem sua utilidade.

O método render :partial recebe um hash com o nome locals. O conteúdo desse hash é disponibilizado dentro do partial como variáveis locais.

Por exemplo:

<%= render :partial => 'example', :locals => {:name => 'Bruno'} %>

Nesse caso estou passando uma variável name com o valor "Bruno" para o partial example.

Mas qual é a utilidade disso?

Vou dar um exemplo prático que aconteceu comigo esses dias.

Minha aplicação tem um model User e, ao criar as views para manipular esse model, percebi que o formulário da view new e o da view edit eram idênticos. Então nada melhor do que colocar esse conteúdo dentro de um partial e reaproveitar o código ao bom e velho estilo DRY (Don't Repeat Yourself).

Fiz isso e meu partial ficou próximo ao do exemplo (clique na imagem para ampliar):

A partir daí eu renderizei esse partial nas duas views (new e edit).

Só que depois de um tempo eu resolvi retirar alguns campos da view de cadastramento (new) para poder tornar o cadastro mais rápido, atraindo mais usuários. Para isso eu removi os campos name e last_name.

Uma vez que agora as views new e edit são diferentes, eu só posso manter no partial o que é comum às duas, então mantive no partial apenas a parte interna do formulário, com exceção dos campos mencionados. O partial ficou assim:

E para renderizar esse partial, eu deixei a view como de costume (render :partial):

O problema é que, o objeto "f" que é passado ao bloco do helper form_for está sendo criado na view e não existe dentro do partial. Quando o partial tentar acessar o "f" retornará um erro dizendo "undefined local variable or method `f'".

Para resolver esse problema, eu vou enviar para o partial o objeto "f", para que ele exista em seu escopo e solucione o meu problema.

Resultado (linha 4):

Problema resolvido!

É isso aí pessoal, espero que a dica ajude alguém que esteja com esse problema, ou pelo menos incentive o reaproveitamento de código nas views.

Abraços e até o próximo post!

Definir o timezone de seu projeto Rails

2009-08-02T20:34:00.003-03:00

Se você criar um projeto rails aqui no Brasil e não definir o timezone, perceberá que as horas estarão sendo exibidas de forma errada.

Isso acontece porque a partir da versão 2.1 o Rails corrige as horas para o timezone UTC por padrão.

O timezone é definido no arquivo config/environment.rb, você encontrará a seguinte linha nesse arquivo:

config.time_zone = 'UTC'

Para saber qual é a nomenclatura do timezone da sua região você pode utilizar o comando:

rake time:zones:local

No meu caso, o resultado é:

* UTC -03:00 *
Brasilia
Buenos Aires
Georgetown
Greenland

E a opção que mais se enquadra para mim é "Brasilia", então irei alterar a linha de meu environment.rb para:

config.time_zone = 'Brasilia'

Agora basta reiniciar o servidor e as horas estarão sendo exibidas da forma correta para a minha região.

Abraços.

Criar atalhos para seus comandos no Ubuntu

2009-08-02T19:28:00.004-03:00

Já que é pra falar de Linux, aí vai mais uma dica rápida.

Se você tem comandos extensos que utiliza com frequência, você pode simplificar sua vida criando atalhos (alias) para esses comandos.

Por exemplo, eu acho os comandos pra ligar e desligar o servidor mongrel um tanto quanto extensos para digitar várias vezes ao dia:

mongrel_rails start -d
mongrel_rails stop

Então para me ajudar eu criei alguns alias no arquivo .bashrc que me permitem acessar esses comandos apenas digitando:

mstart
mstop

Como fazer isso?

Simples, abra o arquivo .bashrc com o comando:

gedit ~/.bashrc

(utilizei o gedit porque acho que é um editor acessível a todos, mas você pode usar o que achar melhor)

Insira no final do arquivo as linhas e salve-o:

alias mstart="mongrel_rails start -d"
alias mstop="mongrel_rails stop"

A sintaxe é simples:

alias nome_do_atalho="comando"

E a partir daí você pode começar a usar comandos mais curtos!

Acredito que você precise reiniciar o micro pra começar a funcionar.

Essa dica foi para Ubuntu mas funciona em outras distribuições do Linux, o que muda as vezes é o nome do arquivo.

Abraços e até o próximo post!

Procurar arquivos no Linux a partir de um trecho de texto contido nele

2009-08-02T14:51:00.003-03:00

Hoje darei uma dica sobre Linux que pode ser bem útil em seu dia a dia.

Vamos dizer que você escreveu um texto em um arquivo certo tempo atrás e hoje você lembra o que tem escrito nele mas não lembra o nome do arquivo. Ou vamos dizer que você alterou o nome de um método em seu projeto e precisa alterar todos os arquivos que usam o método com o nome antigo. Como encontrar esses arquivos?

Para procurar arquivos em um diretório a partir de um trecho contido dentro do dele existe o comando grep.

Por exemplo, vamos dizer que eu queira encontrar todos os arquivos que contém o trecho de texto "user" dentro do diretório atual.

Eu usaria:

grep "user" *

A sintaxe é "grep opções texto arquivo"

Eu posso usar também:

grep -Ri "user" *

O "R" diz pra ele procurar também em subpastas e o "i" diz pra ele não diferenciar maiúsculas de minúsculas.

Poderia melhorar utilizando:

grep -Rin "user" *

Com a opção "n" ele me retornaria também o número da linha em que o texto foi encontrado.

O grep pode ser usado também para filtrar o resultado de um outro comando, por exemplo:

lspci | grep "nVidia"

As aspas são opcionais para textos de uma palavra só.

Espero que a dica ajude. Na verdade eu estava tentando encontrar um arquivo que continha um trecho de código em meu projeto e o Vinícius Baggio me ensinou como fazer (obrigado!). Aí como achei bem útil resolvi vir aqui e passar a informação adiante.

Abraços.

Dica de livro: Startup, Jessica Livingston

2009-07-29T21:25:00.005-03:00

Essa semana acabei de ler o livro Startup, de Jessica Livingston.

O livro conta a história dos fundadores de várias startups do mundo da tecnologia, todas no formato de entrevista.

Eu estava em dúvida se iria gostar do livro, uma vez que podia ser que ele fosse muito voltado para o lado de negócios e isso não me atrai tanto. Mas ele foi surpreendentemente proveitoso, acredito que o livro que eu mais gostei dentre os últimos que li.

As histórias são incríveis, contam tanto o lado do negócio quanto parte do lado tecnológico.

A escolha dos entrevistados também foi excelente, vou listá-los abaixo:

Steve Wozniak, Apple Computer
Mike Lazaridis, Research In Motion (criadora do BlackBerry)
Sabeer Bhatia, Hotmail
Evan Williams, Pyra Labs (Blogger.com)
Tim Brady, Yahoo!
Paul Buchheit, Gmail
Craig Newmark, craigslist
Caterina Fake, Flickr
Charles Geschke, Adobe Systems
Blake Ross, Firefox
Bob Davis, Lycos
Max Levchin, PayPal
Mitchell Kapor, Lotus Development
Steve Perlman, WebTV
Mark Fletcher, ONElist, Bloglines
David Heinemeier Hansson, 37signals

A maior semelhança entre todas as histórias de sucesso é o foco em criar um produto de qualidade.

Outro ponto interessante no livro é ver como as empresas do Vale do Silício são ligadas de uma certa forma.

Recomendo totalmente a leitura, mesmo para quem não é do ramo da tecnologia.

O livro é em português, e para quem quiser a versão original em inglês, o nome é Founders at Work.

Mas a tradução não trás nenhum problema grave, só identifiquei alguns erros de digitação, mas muito poucos e não atrapalham na leitura.

Fica a dica então. Aproveito pra falar para quem estiver procurando livros, visite a tag de livros do blog, que está ficando com um conteúdo muito bom.

Estou incluindo nela apenas os livros em que identifico um certo nível de qualidade após concluir a leitura.

Os próximos que eu irei ler são: "Ruby by example" e "Agile estimating and planning", mas ainda estou esperando chegar. Após concluí-los eu comento aqui.

Abraços e até o próximo post.

Questionário para melhorar o Software Livre

2009-07-28T20:45:00.003-03:00

Gostaria de ajudar a divulgar a pesquisa para identificar problemas de comunicação em projetos de software livre que o Fabio Kung postou na lista de discussões do rails-br.

Segue o texto dele:

Olá a todos,

O meu amigo Hugo Corbucci está fazendo uma pesquisa, como parte da sua pesquisa no mestrado, para identificar problemas de comunicação e possíveis soluções.

Se você contribui (ou já contribuiu) para o software livre e puder gastar alguns minutinhos, se importaria em responder o questionário?

http://www.ime.usp.br/~corbucci/floss-survey.html

Eu e o Hugo agradecemos! Quem puder divulgar por aí também seria de muita ajuda.

[]'s

-- Fabio Kung

É isso aí pessoal, quem puder contribuir respondendo ou divulgando (blog, twitter, amigos) eu agradeço.

Abraços.

Quinto encontro GURU-SP

2009-07-26T14:59:00.009-03:00

Final de semana passado aconteceu aqui em São Paulo o quinto encontro do GURU-SP (Grupo de Usuários Ruby de São Paulo). Foi perto do viaduto do chá, numa sala de reuniões que foi gentilmente cedida pelo pessoal da Voice Technology, (bela iniciativa, valeu mesmo!).

Palestra sobre GIT com o Douglas "QMX" Campos

O Guru-SP é um grupo de usuários que fala sobre Ruby, Rails e outros assuntos referentes a Agile. Nos reunimos com frequência para trocar conhecimentos. Esse foi o quinto encontro do grupo, e o terceiro que participo.

Coding Dojo no final da tarde

Nosso encontro começou pela manhã com uma apresentação de todos presentes e uma ótima introdução ao Rails comandada pelo Rafael Rosa "Fu".

Depois fizemos uma pausa para o almoço e quando voltamos o Rafael mandou mais uma ótima palestra, dessa vez um pouco mais avançada, sobre o ORM Data Mapper. O qual me impressionou muito, é uma boa opção para vários projetos (principalmente os que envolvem bancos legados) e vai ficar ainda mais viável quando vier o Rails 3.0 com a possibilidade de trabalhar com outros ORM de forma mais fácil.

A próxima palestra foi do Douglas Campos sobre o GIT. O cara entende muito de GIT e a palestra foi muito boa, pudemos até interagir num projetinho que fizemos no meio da palestra (alguns scaffolds) e ficamos simulando situações com o GIT (algumas até que não estavam previstas, mas que o Douglas soube se virar muito bem - desculpa pelos pushs inesperados!).

No final da tarde ainda fizemos um coding dojo, onde o Vinícius Baggio foi a frente para manipular o projeto que criamos todos juntos, para abordar temas como testes com Rspec e Remarkable.

Esse foi um resumo geral, todas as palestras e o encontro como um todo foi muito proveitoso. Dessa vez a galera compareceu em massa (acho que cerca de uns 25 participantes ou mais) e é muito legal ver o grupo crescendo desse jeito.

Com certeza teremos próximos encontros, acredito que o próximo deve ser marcado para setembro. Se você ainda não participa do grupo mas tem interesse, participe da nossa lista de discussões.

As fotos do evento estão disponíveis no link abaixo:

http://apantaliao.multiply.com/photos/album/29/Encontro_Guru-sp

Informações mais detalhadas sobre o evento, assim como vídeos das palestras e outros posts sobre ele podem ser encontrados na página oficial no GURU-SP:

http://guru-sp.com/index.php/Quinto_Encontro

Abraços pessoal e espero que os próximos encontros continuem sempre crescendo com qualidade, assim como está acontecendo.

Rails 2.3.3 liberado!

2009-07-20T22:17:00.003-03:00

Post rápido para avisar que hoje a tarde foi lançada a versão 2.3.3 do Ruby on Rails.

Essa versão contém algumas correções de bugs e algumas novas características, como o método touch para atualizar timestamps de um registro, a opção :primary_key para o belongs_to do ActiveRecord entre outros, como melhorias para utilizar JSON.

Para maiores informações visitem:

http://weblog.rubyonrails.org/2009/7/20/rails-2-3-3-touching-faster-json-bug-fixes

Para fazer a atualização basta utilizar:

sudo gem update rails

Review do curso Certified Scrum Master

2009-07-19T19:01:00.006-03:00

Essa semana participei do curso Certified Scrum Master Training que é o curso oficial para Scrum Masters da Scrum Alliance, lecionado no Brasil pelo Alexandre Magno (Certified Scrum Trainer), numa parceria Adaptworks e Caelum.

O curso aconteceu entre os dias 13 e 16 de julho e estou completamente satisfeito. O Alexandre domina completamente o assunto e ensina de um jeito supreendente, cheio de atividades para nos fazer entender melhor o conteúdo.

Não vou entrar em detalhes quanto as atividades, pois deixo a surpresa pra quem pretende fazer o curso.

Apesar do curso ter acontecido a noite e todos estarmos muito cansados, o Alexandre conseguiu prender a atenção de todos e responder a todas as perguntas dos alunos satisfatoriamente, usando sua ampla experiência profissional para exemplificar.

O Scrum é muito diferente do que eu imaginava, até mais atraente do que minha ideia inicial, mas muito mais difícil de ser implantado do que eu previa.

As instalações do curso foram em local adequado (hotel Green Place Flat) e de fácil acesso, pelo menos para mim.

Esse era um curso que eu já pretendia fazer há algum tempo, mas tinha lá minhas dúvidas se eu gostaria e se valeria o investimento.

Como já disse, estou completamente satisfeito de ter feito o curso e se você está com essas mesmas dúvidas te indico que faça também.

Agora que tenho certo conhecimento de Scrum, posso dizer que é arriscado fazer um curso de Scrum em uma instituição que não aborde o tema da forma correta.

Pois ele apesar de simples, é difícil, e se for dado importância só para os processos (que geralmente é o que mais atrái todo mundo e muita gente pensa que Scrum é só isso) e deixar a cultura do Scrum de lado (que é o mais importante) com certeza você ao implantá-lo, apesar de ter seus desenvolvedores trabalhando com sprints, daily meetings, planning poker, etc, o que te dará a falsa impressão de estar trabalhando com Scrum, não terá os ganhos que o Scrum de verdade lhe proporciona.

Gostaria de dizer que não estou ganhando nada com esse post, só estou recomendando um curso que achei que deu retorno ao investimento.

Abraços e provavelmente eu devo começar a abordar o assunto Scrum aqui nos posts do blog, uma vez que pretendo me aprofundar mais com ele.

Layouts aninhados no Rails usando content_for

2009-07-11T17:28:00.016-03:00

A criação de layouts em aplicações Ruby on Rails é uma funcionalidade que valorizo muito no framework. Com ela podemos implementar na prática a filosofia de Design de Epicentro (ver livro Getting Real - 37signals).

Por padrão, podemos criar dois tipos de arquivos de layouts no Rails:

Layout para controllers
Layout para a aplicação inteira

Para criar um layout específico para um determinado controller, criamos dentro da pasta app/views/layouts da aplicação um arquivo com o nome:

nome_do_controller.html.erb

Por exemplo:

albums.html.erb

Um exemplo simples do conteúdo desse arquivo seria o seguinte:

Aonde invocamos o método yield será exibido o conteúdo da view da página que estará sendo acessada.

Se criarmos um arquivo parecido mas com o nome de application.html.erb, esse layout irá ser exibido em todas as páginas da aplicação, a menos que exista um arquivo de layout para o controller em questão (como mencionado acima) ou tenha sido informado de forma explícita um outro layout a ser exibido (demonstrarei como em breve).

O que acontece é que muitas vezes precisamos de dois ou mais layouts diferentes em nossa aplicação, mas parte desses layouts são iguais entre si. E replicar essas partes iguais em todos os layouts fere o princípio de DRY (Don't Repeat Yourself) e acaba causando uma série de retrabalhos.

Imagine que você altere essa parte repetida do layout em um dos arquivos e esquece de mudar nos demais?

Para isso, vou lhes apresentar uma solução que utilizei esses dias em uma aplicação minha. Na verdade encontrei essa solução no endereço abaixo, e apenas dei uma pequena adaptada para ficar mais fácil de trabalhar:

http://blog.jerodsanto.net/2008/06/rails-nested-layouts

Imagine que o layout de nosso site é parecido com a figura abaixo:

Onde possuímos um espaço para o logotipo, um espaço para o conteúdo e um espaço para uma sidebar que contém o menu.

Agora imagine que em determinada parte do sites precisamos exibir algumas fotografias grandes, e seria preciso retirar o sidebar para poupar espaço.

Para não termos que criar dois layouts praticamente idênticos, faremos eles com apenas as partes que são diferentes, e o que for igual deixaremos em um layout separado, o qual os dois incluirão. Conforme demonstrado na figura:

Podemos chamar isso de layouts aninhados, ou, no termo em inglês, nested layouts. Onde dois layouts simples herdam informações de um layout que trás informações comuns aos dois.

Para nos ajudar a implementar nossa solução utilizaremos um helper do Rails chamado content_for.

Com content_for podemos armazenar o conteúdo de uma determinada parte do nosso site para ser exibida depois em algum lugar específico, por exemplo:

O que é armazenado dentro do bloco do helper content_for é exibido depois em:

<%= yield :list %>

Então para solucionar nosso problema nós iremos criar dois layouts:

application.html.erb (que contém o sidebar e será exibido em todas as páginas da aplicação)
expanded_content.html.erb (que será exibido apenas nas páginas que precisam de mais espaço para o conteúdo)

E um outro arquivo que conterá toda a base do site:

base.html.erb

Tanto o application.html.erb quanto o expanded_content.html.erb definirão o que deverá constar no content_for :content, e depois renderizarão o base.html.erb, que contém um lugar definido para exibir o conteúdo de :content.

application.html.erb

expanded_content.html.erb

base.html.erb

Eu coloquei o conteúdo do sidebar dentro de um partial, para melhorar a visualização do exemplo.

Do jeito que está, todas as views serão exibidas utilizando o layout application.html.erb, uma vez que ele é o layout padrão da aplicação e "expanded_content" não é o nome de um controller.

Então como eu faço para utilizar o layout expanded_content.html.erb?

Você tem duas opções:

1) Se você deseja aplicar este layout à todas as views de um determinado controller, basta adicionar a seguinte linha no controller:

layout 'expanded_content'

Exemplo:

2) Se você deseja aplicar esse layout apenas a uma determinada action de seu controller, basta informar o layout na hora de renderizar a view, exemplo:

Com isso não duplicamos código e podemos administrar melhor nossa aplicação.

Gostaria de agradecer ao Shairon Toledo que me falou da existência do content_for la no grupo rails-br.

Espero que tenho gostado da dica.

Qualquer dúvida podem entrar em contato (e-mail, comentário, twitter).

Abraços!

Listando anotações em aplicações Rails utilizando o Rake

2009-07-04T11:35:00.004-03:00

Recentemente comecei a ler o livro do Rodrigo Urubatan, Desenvolvimento Fácil e Rápido de Aplicações Web Ruby on Rails, tinha comprado faz algum tempo, mas ele entrou na fila dos livros que eu já estava lendo.

Agora de manhã, na parte que ele ensinava como listar as funcionalidades do utilitário Rake (rake -T) e descrevia as mais importantes, me interessei bastante por uma delas, acho que vai facilitar o desenvolvimento de algumas aplicações minhas.

Estou falando do comando:

rake notes

Este comando lista todos os comentários em sua aplicação que começam por FIXME, OPTIMIZE e TODO.

Por exemplo, em um controller, eu adicionei o seguinte comentário:

# OPTIMIZE create_pack action needs to be refactored

Como mostra a imagem (clique para ampliar):

Quando, no diretório raiz da minha aplicação, eu executo o comando rake notes, ele me retorna:

rake notes
(in /home/bruno/projetos/escolinha)
app/controllers/pictures_controller.rb:
 * [ 31] [OPTIMIZE] create_pack action needs to be refactored

Lembrando que por enquanto minha aplicação só tem essa anotação, se existissem outras, ele listaria também.

Além desse comando, você pode utilizar também:

rake notes:fixme
rake notes:optimize
rake notes:todo

Que listam tipos de anotações específicos.

Fica aí a dica, essa é uma funcionalidade que está disponível a partir do Rails 2.0, e ajuda bastante para lembrar o que ainda precisa ser feito.

Abraços e até o próximo post!

Firefox 3.5 lançado!

2009-06-30T20:35:00.005-03:00

Post rápido pra divulgar o lançamento da versão 3.5 do Firefox!

Visitem: http://br.mozdev.org

Dica de livro: The Pragmatic Programmer

2009-06-28T19:55:00.005-03:00

Já citei trechos desse livro pela menos duas vezes aqui no blog e, agora que terminei de lê-lo, gostaria de indicá-lo a todos os programadores que passam por aqui.

O livro The Pragmatic Programmer, from journeyman to master fala sobre programação em geral, sem focar em nenhuma linguagem específica e sim, no ato de programar. Mostra como deve se comportar um programador pragmático, e o que é isso.

O livro foi escrito por Andrew Hunt e David Thomas, dois experientes programadores. Recomendo a leitura a todos. O livro mudou minha maneira de programar, com certeza.

Infelizmente não há uma versão em português do livro, mas para quem tem a possibilidade de ler em inglês, não perca essa oportunidade.

O livro pode ser comprado aqui.

Não é uma propaganda ao site de comércio eletrônico, só estou querendo mostrar que não é difícil comprar um livro internacional pela internet aqui no Brasil. Existem sites que vendem esse tipo de conteúdo quase pelo mesmo preço do item em seu país de origem.

Abraços, até o próximo post!

Proposta de criação de um Hackerspace em São Paulo

2009-06-24T22:53:00.004-03:00

O Hugo Borges (agaelebe do GURU-SP) acaba de postar no blog dele uma proposta de um projeto de criar um Hackerspace na cidade de São Paulo.

A ideia dele é muito interessante, seria uma ótima oportunidade para todos os amantes de tecnologia da cidade.

Convido a todos a ler o post original no blog dele, e também a ajudarem a tornar isso possível.

Link: http://www.agaelebe.com.br/2009/6/25/hackerspace_em_sao_paulo

Basicamente um hackerspace é um lugar físico, uma espécie de laboratório que reune pessoas interessadas em certos tópicos de estudo, geralmente ligados a tecnologia, como projetos DIY (faça você mesmo), software, eletrônica, robótica, tecnoarte, entre outros. Além da realização destes projetos o hackerspace pode promover minicursos e eventos, buscando disseminar o conhecimento adquirido.

Abraços.

Dicas para refatoramento

2009-06-22T22:08:00.005-03:00

Hoje li um texto que gostaria de passar adiante. Foi, novamente, no livro The Pragmatic Programmer - from journeyman to master - onde o autor citou algumas dicas de Martin Fowler a respeito de refactoring (refatoramento):

Não tente refatorar e adicionar funcionalidades ao mesmo tempo.
Esteja certo que você tem bons testes antes de começar o refatoramento. Execute os testes sempre que possível. Desta forma você saberá rapidamente se suas alterações quebraram algo.
De passos curtos e cautelosos: mova um campo de uma classe para outra, una dois métodos similares em uma super classe. Refatoramento frequente envolve criar muitas mudanças localizadas que resultam em uma mudança de larga escala. Se você manter seus passos pequenos, e testar depois de cada passo, você evitará debugs prolongados.

Martin Fowler é uma figura respeitada na área de desenvolvimento de softwares, principalmente no que diz respeito a orientação a objetos.

Acredito que essas dicas são valiosas para um bom refatoramento.

Abraços pessoal, e até o próximo post.

Entendendo símbolos em Ruby (tradução)

2009-06-19T21:18:00.011-03:00

Ontem eu estava no rails-br e um integrante do grupo citou o link para um artigo sobre símbolos no Ruby, escrito por Kevin Clark. Achei o artigo muito útil e resolvi traduzí-lo para o português para ajudar quem estiver com dúvidas em símbolos.

Sinceramente, eu também aprendi muito com o texto. Eu sabia quando utilizar os símbolos, mas não o porque.

Então segue abaixo o texto, qualquer crítica quanto à tradução, correção ou outro tipo de comentário será bem vindo. Lembrando que todos os créditos do texto são de Kevin Clark, o autor do original.

Para quem lê em inglês, este é o link do original:

http://glu.ttono.us/articles/2005/08/19/understanding-ruby-symbols

Entendendo símbolos em Ruby

Símbolos em ruby são um enigma. Nós usamos eles, mas muitos não os entendem realmente.

Então, afinal, o que é um símbolo?

De uma forma simples, um símbolo é algo que você utiliza para representar nomes e strings. O que se resume a uma forma eficiente de ter nomes descritivos enquanto você economiza espaço que seria utilizado para gerar uma string para cada instância de nome.

O caso do Dr. Jones

Dr. Jones é um psicólogo. Ele regularmente usa testes de associações de palavras para diagnosticar pacientes e usa ruby para manter um registro de tudo. Seu primeiro paciente, Why, responde dessa maneira:

Dr J: Vermelho
Why: Ruby
Dr J: Transporte
Why: Rails
Dr J: Pedaçudo
Why: Bacon

Dr Jones cria um hash para armazenar seus dados:

why = {"vermelho" => "ruby", "transporte" => "rails", "pedaçudo" => "bacon"}

O segundo paciente do Dr Jones, Bob, entrega os resultados de sua pesquisa:

bob = {"vermelho" => "pintar", "transporte" => "carro", "pedaçudo" => "gordo"}

O problema

Depois de executar várias centenas de testes de associações de palavras, Dr. Jones começa a perceber que ele está estourando a memória! Num palpite, Jones executa testes no irb:

> paciente1 = {"ruby" => "vermelho"}
> paciente2 = {"ruby" => "programação"}
> paciente1.each_key {|key| puts key.object_id.to_s}
211006
> paciente2.each_key {|key| puts key.object_id.to_s}
203536

Bem, vendo isso, cada vez que ele cria um hash para armazenar sua informação, o ruby cria um novo objeto string em uma diferente localização na memória para cada key. Felizmente, existe uma alternativa.

Símbolo ao resgate!

Diferente de strings, símbolos com um mesmo nome são inicializados e existem na memória uma única vez durante a sessão do ruby. Símbolos são obviamente mais úteis quando você reutiliza strings para representar alguma coisa. Reproduzindo o teste do Dr Jones, nós poderemos ver:

> paciente1 = { :ruby => "vermelho" }
> paciente2 = { :ruby => "programação" }
> paciente1.each_key {|key| puts key.object_id.to_s}
3918094
> paciente2.each_key {|key| puts key.object_id.to_s}
3918094

Usando símbolos, nós utilizamos um único endereço de memória para representar a palavra ruby em nosso teste de associação de palavras. Ao longo do tempo, isso pode poupar bastante espaço.

Mas eu não sou um psiquiatra, quando mais eu vou querer usar símbolos?

Símbolos são úteis qualquer hora que você estiver reutilizando uma palavra várias e várias vezes para representar algo, seja ele uma chave em um hash ou o método que você está usando em uma http query.
Um exemplo, do último e melhor e melhor framework web Ruby on Rails, é seu uso de símbolos em rotas e links. O Rails define actions dentre os controllers para fazer coisas no framework antes de renderizar uma página web, então um link em Rails pode se parecer com algo assim:

link_to("Ver Artigo", :controller => "articles", :action => "show",

Quando uma aplicação pode ter centenas de links, ou ao menos centenas de referências para diferentes actions e controllers, é significantemente mais eficiente utilizar símbolos do que strings.

Finalmente, é importante comentar que a utilidade dos símbolos não é restrita às keys em hashes. Por exemplo, se alguém for escrever um cliente ou servidor http ele pode utilizar get e post diversas vezes dentro da aplicação, e pode ser apropriado usar:

do_this if query == :get

...
send_message_to_server(:post,filename)

Qualquer hora que uma string possa ser usada várias e várias vezes, um símbolo pode ser um bom candidato para substituição.

Suporte a multitouch nativo no Linux

2009-06-13T16:52:00.003-03:00

Pessoal, esse é um post off-topic, mas eu achei muito interessante esse vídeo que mostra uma nova característica no Kernel do Linux, o suporte a multitouch.

Abraços!

RnP #1 Como atribuir o endereço do site a uma action

2009-06-09T21:43:00.003-03:00

Para iniciar a série de posts "Rails na prática", vou falar sobre um assunto que foi uma das minhas primeiras dúvidas na hora de implementar um site com Rails.

Ruby on Rais é um framework MVC (Model View Controller) e para acessar uma página geralmente o endereço é composto da seguinte forma:

http://dominio_do_seu_site/nome_do_controller/nome_da_action

O que acontece é que, quando estou criando um site, eu quero que o usuário tenha a opção de acessar meu site direto pelo domínio dele, por exemplo:

http://www.brunograsselli.com.br

Como fazer, então, para que o Rails atribua o endereço de meu domínio à algum endereço reconhecido por ele?

Existe um arquivo dentro do Rails que define os endereços de sua aplicação ou, como ele diz, as rotas. Esse arquivo encontrasse em config/routes.rb

Abra esse arquivo pelo seu editor de texto e digite dentro dele uma linha como, por exemplo:

map.root :controller => "posts", :action => "index"

Isso fará com que, quando eu acessar o endereço do domínio do meu site, o Rails me mostre a página que é montada pela action index do controller posts.

Como eu estou atribuindo à action index, eu poderia apenas informar o controller:

map.root :controller => "posts"

Importante: Além de fazer isso, para que comece a funcionar você precisa também excluir o arquivo que encontrasse em public/index.html

Após excluir esse arquivo, já deve começar a funcionar.

Nesse arquivo encontrasse comentado uma série de formas que você pode definir rotas para sua aplicação. Vale a pena dar uma estudada no assunto para definir endereços mais simples e intuitivos e, também, mais valorizados pelo google.

Você pode encontrar mais informações sobre o assunto em http://guias.rubyonrails.pro.br/routing.html

Espero que o texto ajude quem está começando a se aventurar no RoR, em breve continuarei com os textos da série que visa ensinar como solucionar algumas dúvidas simples que podemos ter no início do aprendizado Rails.

Abraços e até o próximo post.

Rails na Prática

2009-06-07T23:21:00.003-03:00

Desde janeiro que eu venho estudando Ruby e Ruby on Rails a fundo. Fiz um curso no começo do ano na Caelum (ótimo curso) e desde então estou apaixonado por essa linguagem e sempre que dá estou procurando algo a respeito.

Apesar de estar sempre lendo livros sobre Rails (na verdade, mais Ruby do que Rails) e participando da comunidade, ainda não tinha começado a fazer nenhum projeto em Rails pra valer.

Esse final de semana, finalmente, comecei meu primeiro projeto e já me deparei com uma série de dúvidas. E é por isso que venho aqui escrever para vocês.

Minha proposta é, nos próximos posts, escrever a respeito de todas essas dúvidas e curiosidades que eu venho enfrentando nesse primeiro projeto. Na maioria das vezes coisas simples, que nas linguagens que estamos habituados a utilizar fazemos sem problema, mas quando vamos fazer no Rails acabamos parando pra pensar:

"Putz, não havia pensado nisso. E agora, como se faz isso?"

E corremos atrás do google e dos amigos nas comunidades.

Toda vez que estou me deparando com uma situação como essa, estou fazendo minhas anotações para depois vir aqui falar a respeito, na série de posts que eu vou chamar de Rails na Prática (RnP).

Ainda nessa semana pretendo fazer o primeiro post sobre o tema.

Espero que gostem e se tiverem sugestões por favor entrem em contato por e-mail, comentário, ou twitter.

Abraços e até o próximo post.

Link para denúncias no portal da Anatel

2009-06-06T20:01:00.003-03:00

Recentemente eu tive alguns problemas com o serviço de internet móvel da Claro SP, então, durante dois dias, tentei entrar em contato com eles mas, após escolher a opção abrir reclamação, fiquei esperando por mais de meia hora sem ser atendido.

A solução que eu tive para solucionar esse problema foi bem simples e gostaria de divulgá-la para que todos possam exercer seu direito.

No portal da Anatel (http://www.anatel.gov.br) existe um opção de Atendimento Eletrônico (dentro do link fale conosco).

Lá você pode abrir uma denúncia contra esse tipo de serviço em operadoras de telefonia, internet, radio e tv por assinatura.

Após abrir a denúncia a operadora tem 5 dias para solucionar o problema, senão é punida.

Comigo funcionou perfeitamente, no dia seguinte a Claro já estava desesperada atrás de mim.

Passe essa informação adiante no seu blog, twitter, etc, para melhorarmos a qualidade desse tipo de serviço.

Até o próximo post,

Abraços.

Programa para criar diagramas no Linux

2009-05-31T14:33:00.010-03:00

Hoje precisei criar alguns fluxogramas para o meu TCC e, para não ter que correr atrás de instalar o Microsoft Visio na virtual machine, procurei algum programa que fizesse o mesmo no Linux / Gnome.

Encontrei o Dia, programa open source criado com a mesma ideia do Visio, que lhe permite criar uma série de diagramas.

Para quem estiver precisando de um programa para isso, recomendo o Dia. Ele supriu todas as minhas necessidades na criação do TCC e, provavelmente, vai começar a me ajudar em meus projetos.

Ele trabalha com diversos tipos de diagramas, inclusive os diagramas de UML, e te dá a opção de exportar o diagrama em diversos formatos de imagem, entre eles, o png.

Você pode instalar o Dia facilmente através do gerenciador de pacotes da sua distribuição.

No Ubuntu, você pode digitar no console:

sudo apt-get install dia

Ou procurar por ele no próprio Synaptic (Sistema/Administração/Gerenciador de Pacotes Synaptic).

Abaixo seguem endereços para os sites do projeto:

http://live.gnome.org/Dia
http://projects.gnome.org/dia

Programe de forma simples

2009-05-21T21:42:00.006-03:00

Li há uns meses atrás no livro The Pragmatic Programmer, from journeyman to master o seguinte trecho:

Programmers are taught to comment their code: good code has lots of comments. Unfortunately, they are never taught why code needs comments: bad code requires lots of comments.

A tradução seria algo como:

Programadores são ensinados a comentar seus códigos: código bom tem um monte de comentários. Infelizmente, eles nunca são ensinados porque código precisa de comentários: código ruim requer um monte de comentários.

Lembrei deste capítulo esses dias quando minha professora de engenharia de software afirmava que código bom é código comentado.

Um código bem escrito fala por si só, comentários nesse caso poderiam ser encarados até como duplicação de informação (DRY, don't repeat yourself).

Mas o que eu chamo de código bem escrito?

Nem sempre o algoritmo que resolve uma solução com menos linhas, ou até mesmo um que obtém um melhor desempenho, é a melhor solução para um determinado problema. Programação é mais do que bons algoritmos, trata também de legibilidade, utilização de padrões, código flexível e reutilizável, entre outros.

Esse algoritmo com menos linhas, pode ser algo não reutilizável em situações similares. Ou um código que, por utilizar uma solução não convencional (gambiarra), pode não ser tão legível para outro programador, ou para você mesmo daqui uns meses.

Eu tento sempre quando estou programando pensar em soluções simples. Na maioria das vezes eu penso em como eu faria se fosse feito manualmente e então implemento algo que siga o mesmo caminho, utilizando os benefícios que a linguagem e o framework me proporcionam.

Por exemplo, vamos dizer que eu tenho uma pilha de tijolos de lego em meu sistema, e tenho que desenvolver um processo nele onde ele encontre uma quantidade determinada de tijolos de uma mesma cor. Por exemplo, eu quero que ele busque 5 tijolos vermelhos.

Se eu fosse fazer manualmente, eu correria os tijolos com os olhos (utilizando a mão se necessário) verificando a cor de cada um e iria separando os vermelhos até obter a quantidade esperada. Se eu não encontrasse a quantidade necessária, sabendo que lá é o único lugar para conseguir os tijolos, alertaria a quem me pediu.

Para implementar o sistema eu faria da mesma forma. Solicitaria a cor e a quantidade desejada. Correria um laço pelos tijolos disponíveis peguntando a cada um deles qual é sua cor. Logo, a classe tijolo teria de ter um método que diz sua cor. Se encontrasse quantos eu precisasse eu retornaria a quem me pediu. Se ao chegar ao final eu não tivesse encontrado, retornaria um erro, ou exceção (dependendo de quão comum fosse essa escassez dos tijolos - se fosse algo possível de acontecer, erro, se fosse algo que não deveria acontecer, exceção).

Mas, e se eu descobrisse que os tijolos vermelhos são mais leves dos que os demais e que, se eu desse uma pancada na mesa, os tijolos vermelhos seriam os únicos que pulariam acima de 20 cm de altura? Iria eu utilizar isso para desenvolver uma técnica mais rápida de conseguir os tijolos vermelhos?

Provavelmente não. Ainda assim eu optaria pela primeira solução, por diversos motivos:

Ela é a solução mais esperada, se alguém ler esse código com certeza vai entender do que se trata, mesmo ele não estando comentado.
E se um dia os tijolos azuis ficarem mais leves ou tão leves quanto os vermelhos?
A primeira solução funciona para qualquer tipo de tijolo, independente da cor.
A primeira solução, por ser simples, é mais flexível e extensível. A segunda opção, por tratar uma situação muito específica, será mais difícil de expandir ou alterar quando os usuários solicitarem. E acreditem, todo código nasce para ser expandido ou alterado futuramente. Se ainda não solicitaram isso, irão.

Precisamos sempre avaliar o código que estamos criando por diversos fatores diferentes. Muitas vezes uma melhor legibilidade vale mais do que uma pequena melhora de desempenho ou um código menor. É necessário avaliar quais são as reais prioridades no projeto.

Se por algum motivo você tiver que optar por uma solução não convencional, aí seria indicado deixar um comentário. Se você perceber que seu código está ficando com muitos comentários, o melhor é reavaliar se seu programa está indo na direção correta.

Uma programação de forma simples pode lhe trazer diversos benefícios, portanto fique sempre atento ao método como você está programando.

Configurar login automático no Ubuntu

2009-05-17T11:47:00.003-03:00

Na versão anterior que eu tinha do Ubuntu eu usava a opção de login automático (Início automático de sessão), para não ter que digitar usuário e senha toda vez que ligasse o laptop, mas quando fiz o update para a versão 9.04 Jaunty Jackalope o sistema voltou a solicitar as informações de login para iniciar.

Se você teve esse mesmo problema, ou se simplesmente deseja habilitar essa opção, vá em:

Sistema -> Administração -> Janela de início de sessão

Vá até a aba Segurança, habilite o opção Habilitar início automático de sessão e informe o usuário que o Ubuntu deverá usar para iniciar a sessão.

E assim o Ubuntu voltará a efetuar o login automaticamente.

Até mais!

Disponível nova edição da Rails Magazine

2009-05-13T21:26:00.003-03:00

Post rápido para avisar que já está disponível para download a segunda edição da revista Rails Magazine.

É uma edição especial que trás a cobertura do RailsConf 2009 que aconteceu em Las Vegas.

Confiram no link:

http://railsmagazine.com/issues/2

[]s.

Claro 3G no Ubuntu 9.04 conecta mas não navega

2009-05-10T17:45:00.007-03:00

Depois de uma semana e meia tentando, consegui atualizar o meu Ubuntu para a nova versão 9.04.

Os servidores dessa vez estavam muito congestionados.

Após a instalação minha internet banda larga (Claro 3G) parou de funcionar. Ele conectava mas não acessava nenhuma página. Na versão 8.10 tinha dado algo parecido que eu arrumei adicionando a seguinte linha no final do arquivo /etc/ppp/options:

ipcp-max-failure 30

Na versão 9.04, para solucionar o problema, além disso, faça o seguinte:

Acesse Sistema/Preferências/Conexões de rede.

Vá até a aba Banda larga móvel, selecione a sua conexão e clique em editar.

Acesse a aba Configurações IPv4 e no item Método selecione a opção Automático (PPP).

Aqui funcionou perfeitamente após isso.

Abraços e até o próximo post!

Usando TinyMCE no Ruby on Rails

2009-05-06T23:25:00.004-03:00

TinyMCE é um script escrito em javascript que adiciona aos seus campos TEXTAREA, dentre outros elementos do HTML, características avançadas similiares às de um editor de texto, como o Microsoft Word.

Recentemente precisei utilizar um recurso como este em meu projeto de conclusão do curso na faculdade e escolhi o TinyMCE para isso. Encontrei algumas opções para configurá-lo no Rails através de Ruby Gems ou Plugins, mas, não sei se foi por incompatibilidade da minha aplicação ou por falta de conhecimento meu na hora de configurar, não consegui colocar em funcionamento.

Então entrei no site oficial do script (http://tinymce.moxiecode.com) e procurei a respeito de como configurá-lo manualmente. O procedimento para isto é extremamente simples, vou descrever a seguir.

Para começar irei criar uma aplicação de Rails simples utilizando scaffold, para que vocês possam acompanhar na prática o procedimento e para não fugirmos muito do escopo do post.

Sendo assim, abrirei o console e digitarei os seguintes comandos no diretório onde costumo gravar meus projetos de RoR (Ruby on Rails):

rails notes -d mysql

Nosso projeto de exemplo será um programa para criação de anotações, por isso o nome "notes" e, como utilizo banco de dados MySQL, utilizei os parâmetros "-d mysql".

O comando acima criou nosso projeto, agora vou configurar o arquivo config/database.yml para alterar a senha do banco de dados. Para isso estou utilizando o editor de texto gvim, mas você pode escolher o que achar melhor.

cd notes
gvim config/database.yml

Agora vamos criar um model chamado note, que terá um título e um texto de corpo. Como disse, utilizarei scaffold para poupar tempo:

script/generate scaffold note title:string body:text
rake db:create
rake db:migrate

Se você quiser testar para ver se tudo está conforme o planejado, inicie o servidor:

script/server

E acesse o endereço http://localhost:3000/notes/new

Deve estar como na figura abaixo:

A idéia agora é aplicar o TinyMCE a essa textarea da view da figura acima (new.html.erb). Então vamos iniciar a configuração do script em si.

Primeiro de tudo você deve baixar o script no site:

http://tinymce.moxiecode.com/download.php

Hoje, 28 de abril de 2009, a versão atual é tinymce_3_2_3.zip (main package).

Após baixar o arquivo descompacte-o e abra o seu conteúdo.
Dentro do diretório jscripts existe um diretório chamado tiny_mce.

Mova esse diretório para seu_projeto/public/javascripts

Deve ficar assim:

/public/javascripts/tiny_mce

Feito isso abra a view que iremos aplicar o script (app/views/notes/new.html.erb) em seu editor de textos preferido. No meu caso utilizarei o gvim de novo:

gvim app/views/notes/new.html.erb

Primeiramente vamos carregar o script em nossa view. Para isso, ao invés de utilizarmos as tags do html diretamente, utilizaremos os helpers do Rails.

Nesse caso vamos utilizar o método javascript_include_tag, que recebe o nome do javascript como parâmetro.

Então, após abrir a view, adicione logo no início do arquivo a seguinte linha:

<%= javascript_include_tag 'tiny_mce/tiny_mce.js' %>

Deve ficar assim:

E agora vamos adicionar um trecho de javascript que irá configurar como nossa textarea deve ser exibida (que opções de formatação deve conter, etc).

No próprio site do script contém vários exemplos de configurações prontos, assim como uma API e documentação sobre o assunto. Acesse:

http://tinymce.moxiecode.com/examples/full.php

Você pode escolher um dos exemplos e clicar em "View Source" para visualizar o código fonte.

Para nosso exemplo eu utilizarei um exemplo pronto do site denominado "Simple".

Para criar tags de javascript em nossa view utilizarei o método javascript_tag e colocarei o código retirado do site do TinyMCE dentro dele, ficará assim (pode ser logo após a útima linha que digitamos no arquivo):

<% javascript_tag do tinyMCE.init({ mode : "textareas", theme : "simple" }); end %>

Execute o servidor para ver o resultado, deve ter ficado assim:

Eu utilizei a opção de configuração mais simples do TinyMCE, para poupar o código do exemplo. Mas existem muitas outras opções com mais recursos no site de exemplos, cuja dificuldade para a configuração é exatamente a mesma do exemplo.

O script faz com que, após digitar o texto formatado na textarea, ela chegue na action do controller com sua formatação já convertida para as respectivas tags de HTML.

Apenas mais um último detalhe: se você entrar agora na parte de visualização dessa anotação que cadastramos, perceberá que ela não aparece formatada de acordo com o que cadastramos, as tags htmls são exibidas na tela, ao invés da formatação.

Vide imagem:

Isso ocorre porque o scaffold criou as views utilizando o método "h" para imprimir a informação no navegador.

Veja a linha 8 da imagem (arquivo app/views/notes/show.html.erb):

Para corrigir isso basta tirarmos o método "h", como na figura:

E o resultado será:

E com isso temos nossa pequena aplicação funcionando. Espero que o exemplo tenha ajudado a entender a configuração.

Qualquer dúvida estou a disposição no e-mail, twitter ou aqui nos comentários do blog.

Gostaria de agradecer ao Rafael Rosa Fu e ao Fábio Kung por tirar as dúvidas que eu tinha em relação a esse post e também pela ajuda que eles sempre me dão em todos os meus testes com o Rails.

Abraços e até o próximo post!

Nova versão do Ubuntu, 9.04 Jaunty Jackalope, lançada!

2009-04-23T22:57:00.003-03:00

Já está disponível para download ou update a nova versão do Ubuntu, Jaunty Jackalope.

Eu estava desatualizado quando ao desenvolvimento dessa nova versão e o sistema de updates do Ubuntu me pegou de surpresa hoje.

De novo eles cumpriram o prazo estipulado, que era de que a nova versão 9.04 sairia em abril de 2009.

Confiram em:

http://www.ubuntu.com

Abraços!

Vim + Ruby on Rails

2009-04-21T11:26:00.003-03:00

Acabo de ler no blog do Patrick Espake um post muito interessante sobre como adaptar e utilizar o editor de texto Vim do Linux para trabalhar com Ruby on Rails de forma totalmente integrada.

Estava procurando sobre esse assunto ainda esse domingo, mas os artigos que havia encontrado não estavam funcionando completamente quando eu testava. O do Patrick ficou bem legal e estou seriamente pensando em começar a usar o Vim, no lugar do Gedit + Gmate.

Fica aí a dica, acessem o link do post, abaixo, e conheçam mais uma boa alternativa para ambiente de desenvolvimento Ruby on Rails.

http://patrickespake.wordpress.com/2009/04/21/usando-o-vim-para-programar-em-ruby-on-rails/

Queria aproveitar pra falar que agora também estou no Twitter. Ainda estou aprendendo como funciona mas parece uma rede bem interessante. Quem quiser me encontrar lá segue o link:

http://twitter.com/grasselli

Abraços!

Teclas de atalho do Gnome

2009-04-19T16:01:00.006-03:00

Hoje vou fazer um post rápido sobre as teclas de atalho do Gnome. Eu uso Gnome em meu computador pessoal (Ubuntu 8.10) e, no meu serviço, utilizo Windows XP (não por opção). No serviço eu tenho costume de utilizar o atalho "botão do windows + M" para ir direto para a área de trabalho independentemente do número de janelas que estiverem abertas no micro.

Sempre pensei em pesquisar por um atalho semelhante no Gnome mas até hoje nunca tinha ido atrás. Hoje enquanto escrevia um aplicativo pequeno em Ruby para automatizar umas tarefas no meu micro, tomei coragem e descobri no site do gnome.org que o atalho CTRL + ALT + D faz praticamente o mesmo efeito.

Pressionando CTRL + ALT + D uma vez você minimiza todos as janelas abertas e visualiza a área de trabalho, pressionando de novo você restaura as janelas novamente.

Você pode encontrar todos os atalhos no Gnome no endereço:

http://library.gnome.org/users/user-guide/stable/keyboard-skills.html.pt_BR

Vou listar abaixo os que mais utilizo:

ALT + F2
Abre uma janela onde você entra com o nome do aplicativo que deseja executar. Semelhante ao Iniciar -> Executar do Windows (botão do Windows + R).

CTRL + ALT + SETAS
Intercala entre as áreas de trabalho.

CTRL + ALT + SHIFT + SETAS
Envia a janela em foco para outra área de trabalho.

CTRL + ALT + D
Minimiza as janelas ativas.

CTRL + L
Bloqueia o computador.

ALT + TAB
Intercala entre as janelas abertas.

Espero que a dica ajude quem estiver procurando pelo assunto. Usar teclas de atalho sempre trás mais agilidade aos processos.

Estou usando este post também para testar o serviço de postagem por e-mail do Blogger.

Abraços e até o próximo!

O Guia (comovente) de Ruby do Why

2009-04-10T12:29:00.006-03:00

O Carlos Brando anunciou no Nome do jogo o lançamento da versão 1.0 da tradução do livro Why's Poignant Guide to Ruby, depois de quase um ano de trabalho.

Ainda não o li pois estou terminando a leitura do The Pragmatic Programmer, livro que com certeza vou indicar aqui no blog após concluir. Mas confio plenamente na qualidade de um livro escrito pelo Why (criador do Shoes) e indicado pelo Carlos Brando e toda a comunidade Ruby.

Segue abaixo link para o livro, que pode ser lido gratuitamente pela internet:

http://why.nomedojogo.com

E o link para o post original no Nome do jogo:

http://www.nomedojogo.com/2009/04/09/o-comovente-guia-de-ruby-do-why

E para o livro original em inglês, que também pode ser lido gratuitamente:

http://poignantguide.net/ruby

[]s e até o próximo post!

Avaliação Ruby + Rails no Mundo Real 2009

2009-04-07T22:16:00.006-03:00

Sábado passado, dia 4, aconteceu aqui em São Paulo o evento Ruby + Rails no Mundo Real 2009, organizado pelo pessoal da GURU-SP com a ajuda da Tempo Real Eventos, Caelum, entre outros.

Passei por aqui para publicar minha opinião em relação ao evento, ainda que um pouco atrasado.

O público do evento surpreendeu em quantidade e qualidade. Segundo o que o próprio Marcelo Castellani disse no começo da apresentação, eles estavam contando com bem menos gente quando estavam imaginando o evento há uns meses atrás. Não sei o número ao certo mas arrisco dizer que teve em torno de 150 congressistas.

Gostei muito de todas as palestras apresentadas, mas em especial a do Carlos Brando falando sobre testes, a do Rodrigo Franco falando sobre como trabalhar com clientes do exterior e a do Fabio Kung sobre reflection e metaprogramação.

Acredito que em breve os vídeos com as palestras do evento estarão disponíveis na web, vocês podem verificar no site do GURU-SP.

A imagem no topo do post eu roubei do álbum do Hugo Borges sobre o evento (fim da palestra do Carlos Brando):

http://picasaweb.google.com/hugo.borges/RubyRailsNoMundoReal

Resumindo, o evento foi muito bom, valeu a pena, e para os próximos fica o conselho: não faltem.

Abraços a todos!

Concorra a dois workshops mão na massa Ruby e Rails Tempo Real

2009-04-02T22:21:00.005-03:00

Saudações a todos,

Nos últimos dias não estou conseguindo postar muito no blog pois ando meio ocupado com serviço + tcc + um freelance que está me matando mas já estou quase acabando! Espero muito em breve voltar com gás total para o blog, estou cheio de idéias de posts interessantes, especialmente sobre Ruby e Rails e, se tudo der certo, estarei criando novas vídeo aulas também.

Hoje vim aqui para divulgar mais uma iniciativa muito interessante do blog Ruby Inside Brasil, e também para participar da promoção deles =)

O Ruby Inside Brasil estará sorteando dois cursos inteiramente gratuitos. Um sobre Ruby e outro sobre Rails, que acontecerão nos dias 23 e 30 de maio, respectivamente.

Para concorrer basta ajudar a divulgar a promoção em seu blog ou Twitter!

Segue link para o post original:

http://www.rubyinside.com.br/concorra-a-dois-workshops-mao-na-massa-ruby-e-rails-tempo-real-885

E vale lembrar que este sábado, dia 4, estará acontecendo o Ruby + Rails no Mundo Real 2009, encontro vocês lá!

Rails 2.3 lançado

2009-03-16T23:16:00.003-03:00

Post rápido:

Lançada a nova versão do Rails, confira as novidades em:

http://guides.rubyonrails.org/2_3_release_notes.html

Mais detalhes também no blog do Akita (em português):

http://www.akitaonrails.com/2009/03/14/rails-2-3-amanha

Para atualizar:

sudo gem update rails

Até o próximo post!

[]s.

Rails Magazine

2009-03-15T17:43:00.003-03:00

Hoje estou aqui para ajudar a divulgar uma iniciativa que conheci na última semana, a revista Rails Magazine.

É uma revista escrita periodicamente por profissionais e entusiastas de Ruby on Rails, com versão em PDF gratuita disponível na internet.

Confira a primeira edição em http://railsmagazine.com/issues/1!

Essa é mais uma bela iniciativa da comunidade Ruby e Rails. Se você ainda não conhece a linguagem Ruby ou o framework web Ruby on Rails, não perca tempo!

Segue abaixo alguns links que podem te ajudar num primeiro contato:

Comunidades:

Citações sobre especificações

2009-03-09T23:08:00.005-03:00

Especificações inúteis

Uma “especificação” é um documento quase que completamente inútil. Eu nunca vi uma especificação detalhada o suficiente para que seja útil e precisa ao mesmo tempo.

E eu já vi muito lixo construído com base em especificações. Desenvolver com base em especificações é a pior maneira de se escrever software, pois por definição, trata-se de programar para satisfazer uma teoria, não a realidade.

—Linus Torvalds, Criador do Linux (from: Linux: Linus Sobre Especificações)

Enfrente os “atrasadores de projeto”

Eu cheguei à conclusão de que muitas das pessoas que insistiam em uma lista extensiva de requisitos antes de começar qualquer design tratavam-se de meros “atrasadores” tentando frear o processo (e que geralmente estas pessoas não tinham nada a contribuir no design, nem qualquer idéia inovadora para compartilhar).

Todo nosso melhor trabalho foi feito com alguns conceitos na cabeça sobre melhorar o site, alguns protótipos rápidos (estáticos), pequenas alterações no design e, enfim, com a construção de um protótipo funcional com dados reais. Após nos prepararmos com esse protótipo, geralmente tínhamos um projeto real em curso e um bom resultado.

—Mark Gallagher, desenvolvedor de intranets corporativas (de Signal vs. Noise)

Ambos os textos foram retirados do livro Getting Real, da 37signals.

Ruby: getters e setters

2009-03-08T20:27:00.004-03:00

Hoje vou falar um pouco a respeito de variáveis de instância em classes no Ruby e seus métodos de acesso.

No Ruby, diferentemente do Java, todas as variáveis de instância tem controle de acesso private, ou seja, só são acessíveis (escrita ou leitura) diretamente para os métodos dentro da própria classe.

Para explicar melhor o porque isso é uma boa característica da linguagem, vou falar a respeito de acoplamento entre classes.

Em orientação a objetos falamos que acoplamento entre classes é o nível em que uma classe tem acesso aos dados de outra. O ideal é que as classes tenham baixo acoplamento entre si, isso é, acessem as variáveis das outras classes apenas através dos métodos disponíveis por ela (encapsulamento).

Vou dar um exemplo de uma relação de classes com alto acoplamento (característica não recomendada) em Java:

Nesse exemplo temos a classe A e a classe B. A classe B contém um objeto do tipo A.

Note na linha 6 da classe B que ela acessa diretamente a variável de instância name da classe A, uma vez que ela tem nível de acesso public.

Esse tipo de relacionamento pode vir a trazer problemas futuramente, especialmente para a classe B, caso a classe A troque o nome da variável de instância name, ou algo do gênero.

O recomendado nesse caso seria que a variável name tivesse nível de acesso private e a classe disponibilizasse métodos para que classes externas acessem essa variável.

Como no exemplo abaixo:

Dessa vez a classe B utiliza o método setName da classe A para alterar a informação desejada. Dessa forma a classe A pode alterar sua lógica interna futuramente, sem precisar se preocupar com as classes que se relacionam com ela, portanto que ela mantenha os métodos getName e setName funcionando corretamente.

Isso é um exemplo de baixo acoplamento entre classes, e essa é a boa prática.

Como eu estava dizendo, no Ruby as variáveis de instância são sempre privates, o que nos força a trabalhar da forma certa, fornecendo métodos getters e setters para interação com outras classes.

Na verdade existem métodos como o instance_variable_get, que retorna o valor de uma variável de instância, mas métodos como esse só devem ser usados em caso de extrema necessidade. Para o nosso texto, vamos utilizar os métodos getters e setters.

Então toda vez que eu criar uma classe tenho que construir métodos getters e setters para cada uma das variáveis de instância que eu desejar deixar disponível para leitura ou escrita por outras classes?

Na teoria sim, mas o Ruby possui alguns métodos que nos ajudam bastante para esse tipo de tarefa, são eles : attr_accessor, attr_reader e attr_writer.

Por exemplo, vou criar uma classe User, dessa vez em Ruby, que possua as variáveis de instância name e age, as quais eu vou permitir que qualquer outra classe leia e altere seus valores (portanto vou criar métodos getters e setters).

Para acessar os dados das variáveis de instância de um objeto dessa classe seria dessa forma:

Por enquanto lembra um pouco o Java, certo?

Agora vamos usar uma técnica bem interessante. Vamos nomear os métodos getters com o mesmo nome da variável e os métodos setters com o nome seguido de um sinal de igual (=), veja o exemplo:

Agora podemos acessar os valores de um objeto dessa classe da seguinte forma:

Isso é possível graças há uma grande característica do Ruby chamada Syntactic Sugar, que torna possível a criação de códigos mais amigáveis. No caso do exemplo acima o Ruby nos permite adicionar um espaço antes e depois do sinal de igual e não usar parênteses para invocar o método.

Agora vamos falar sobre a parte interessante. Na verdade todo esse trabalho não precisa ser feito se eu for apenas criar métodos que permitam acesso ao conteúdo de uma variável.

Existe um método chamado attr_accessor que faz todo esse trabalho para nós (cria a variável de instância e os métodos getters e setters para ela).

Para isso basta eu chamar o método e passar como parâmetros o nome dos campos que eu desejo que sejam minhas variáveis de instância. No caso de nosso exemplo, ficaria da seguinte forma:

E poderíamos acessar os dados da mesma forma que no outro exemplo:

Como dito acima, o método attr_accessor cria métodos de acesso para leitura e escrita das variáveis de instância passadas a ele. Para os casos em que precisamos criar apenas os métodos de leitura ou escrita, usamos os métodos attr_reader e attr_writer, em seu lugar.

Bom pessoal, essa foi mais uma pequena contribuição no blog para o pessoal que deseja aprender mais sobre a linguagem Ruby, a qual eu recomendo e encorajo o aprendizado.

Para ler mais a respeito visitem a API do ruby e procurem pelos métodos attr_accessor, attr_reader, attr_writer e attr.

Gostaria de agradecer ao Fábio Kung que me tirou dúvidas a respeito desse post e está sempre me ajudando por e-mail.

Espero que o post ajude, qualquer dúvida ou crítica podem mandar e-mails ou postar comentários.

Até o próximo post.

Abraços!

Como reinstalar o GRUB

2009-03-07T19:20:00.009-03:00

Hoje passei por alguns apuros em meu laptop, enquanto instalava o Archlinux em uma nova partição do disco rígido.

No meio da instalação via FTP, meu cabo de rede parou de funcionar e não voltou mais.

Reiniciei o micro para bootar pelo Ubuntu (que era a distribuição que estava instalada antes) e descobri que o GRUB não carregava mais.

Aparecia algo como:

Loading GRUB:
Error 15

Vim aqui passar adiante a solução que encontrei, para que ajude quem estiver com esse mesmo problema.

Para reinstalar o GRUB faça o seguinte:

Inicie o computador utilizando algum Live CD como o do Ubuntu, por exemplo.

Inicie o console e digite:

$ sudo fdisk -l

Ele listará as partições de seus discos rígidos, localize qual é a partição onde está instalado o seu linux. No meu caso é /dev/sda6.

Digite:

$ sudo grub

Ele iniciará um aplicativo em modo texto, dentro dele digite:

$ root (hd0,x)

Onde x é o número da sua partição. Como a minha é sda6, o número dela é 5, pois a contagem começa do zero.

Portanto, no meu caso o comando foi:

$ root (hd0,5)

Então digite:

$ setup (hd0)
$ quit

Reinicie o micro e veja se está funcionando.

Espero que o post ajude.
Até o próximo.

Barcamp Locaweb de Ruby e Rails

2009-03-01T13:34:00.003-03:00

Pessoal,

Estou postando para ajudar a divulgar mais uma iniciativa muito interessante do pessoal da comunidade Ruby.

Mas detalhes no post do blog do Fábio Akita:

http://www.akitaonrails.com/2009/2/26/barcamp-locaweb-de-ruby-e-rails

Abraços!

Como instalar o Mongrel

2009-02-22T23:27:00.009-03:00

Uma dica rápida para quem, assim como eu, está começando em Ruby on Rails.

Mongrel é um rápido e simples servidor web para aplicações Rails, para instalá-lo e utilizá-lo em seus aplicativos, siga os passos a seguir:

Instalação:

$ sudo gem install mongrel

Iniciando o servidor:

Acesse o diretório de sua aplicação, por exemplo:

$ cd meuprojeto

Inicialize o servidor:

$ mongrel_rails start -d

Para finalizá-lo utilize:

$ mongrel_rails stop

Se precisar reiniciá-lo:

$ mongrel_rails restart

Mongrel é um servidor muito mais rápido que o WEBrick (o servidor que vem instalado por padrão junto ao Ruby on Rails) e é tão simples de usar quanto.

Espero ter ajudado com a dica, abraços e até a próxima!

Links relacionados:

http://mongrel.rubyforge.org

Upload de imagens no Rails com Paperclip

2009-02-21T12:08:00.026-03:00

Hoje vou escrever um tutorial sobre como fazer upload e redimensionamento de imagens no Ruby on Rails (RoR) utilizando o plug-in Paperclip.

O Paperclip é um plug-in muito simples de usar, estou utilizando ele em um projeto pessoal e é meu favorito para esse tipo de tarefa.

Vou ensinar como usá-lo dando um exemplo prático. Vamos criar um projeto que tem uma classe user (usuário) com os campos name (nome) e picture (fotografia).

Vamos criar uma tela de cadastro de usuários e uma tela que liste os usuários cadastrados, para podermos ver o Paperclip em ação.

Criando o projeto.

Para começar vamos criar nosso projeto, para isso vá para o seu diretório de projetos e digite o comando:

$ rails example --database=mysql

O nome do meu projeto é example e estou utilizando banco de dados mysql. Se você quiser utilizar outro nome ou banco de dados fique à vontade.

Estou utilizando nome de variáveis em inglês pois recentemente comecei a seguir a recomendação que o Carlos Brando fez no post Rails Way #3: Nomes de métodos e variáveis devem ser óbvios, recomendo a leitura.

Configurando o banco de dados.

Agora que o nosso projeto está criado vamos configurar o banco de dados, para isso abra o arquivo que está em config/database.yml com seu editor de textos.

Escreva a senha de seu banco de dados nos respectivos lugares para os bancos development, test e production.

Ficará similar à figura abaixo (a senha do meu banco de dados é root):

Instalando o plug-in Paperclip.

Agora vamos instalar o plugin do Paperclip em nosso projeto. Digite, no diretório do projeto, o comando:

$ script/plugin install git://github.com/thoughtbot/paperclip.git

Ps. Você precisará ter o git instalado para executar esse comando, se você ainda não tem confira o post Instalar GIT no Ubuntu.

Criando o model user.

Agora vamos criar a classe user.

Como dito anterirmente, nossa classe terá os campos name e picture, que será o campo que amazenará a fotografia do usuário.

Para que o paperclip funcione, ao invéz de criar os campo picture no model, criaremos os seguintes campos:

picture_file_name (string)
picture_content_type (string)
picture_file_size (integer)
picture_updated_at (datetime)

Onde picture é o nome que usaremos para se referir a imagem. Portanto se o nome que você escolheu fosse image, por exemplo, os nomes dos campos seriam image_updated_at, image_file_name e por aí vai.

Digite o seguinte comando para criar o model user:

$ script/generate model user name:string picture_file_name:string picture_content_type:string picture_file_size:integer picture_updated_at:datetime

Configurando o campo picture na classe user.

Agora vamos dizer para a classe user que ela tem uma imagem que responde pelo nome de picture.

Para isso abra o arquivo que está em app/model/user.rb e adicione dentro da classe a linha:

has_attached_file :picture, :styles => {:small => "150x150", :large => "550x550"}

Onde small e large são tamanhos que eu defini para que minha imagem tenha. Então quando eu fizer o upload de uma imagem o paperclip salvará, também, uma cópia dela nos tamanhos que eu especifiquei.

Você pode definir mais tamanhos se quiser (ou menos) e os nomes ficam a seu critério.

O arquivo ficará assim (clique na imagem para ampliar):

Criando o banco de dados.

Agora para criar os bancos de dados e a tabela users vamos utilizar o rake.
Digite os comandos:

$ rake db:create:all
$ rake db:migrate

Criando o controller para user.

Agora vamos criar um controller para manipular o model user. Digite o comando:

script/generate controller users

Abra o arquivo gerado (app/controllers/users_controller.rb) e vamos criar as actions index, new e create. Por enquanto vamos deixá-las em branco, ficará assim:

A action index listará os usuários cadastrados, a action new carregará o formulário de cadastro e a create criará o usuário digitado no formulário.

Criando o formulário de cadastro.

Vamos criar a view para o formulário de cadastro, crie o arquivo app/views/new.html.erb

Dentro dele crie o formulário de cadastro, veja o meu de exemplo (clique: na imagem para ampliá-la):

Lembrando que todo formulário que possui um campo file_field precisa ter o parâmetro :html => { :multipart => true } para funcionar. Senão o navegador não irá transferir o arquivo.

Criando a action create.

Agora vamos criar a action que cadastrará os dados do formulário, a action create.

Ela ficará assim (app/controllers/users_controller.rb):

Essa action recebe os dados do formulário, cria um objeto do tipo user com esses dados e o salva no banco de dados. Se o procedimento deu certo ela vai para o index, que listará os usuários cadastrados, senão ela retorna para a página de cadastro.

Criando a view para o index.

Agora que nosso projeto já cadastra usuários, vamos criar a view index para listá-los.

Primeiramente faça com que a action index do controller users carregue uma variável com os usuários cadastrados, para isso (app/controllers/users_controller.rb):

Agora, para criar a view, crie o arquivo app/view/users/index.html.erb

Veja o meu de exemplo (clique na imagem para ampliá-la):

Para exibir a imagem eu usei:

<%= image_tag u.picture.url(:small) %>

Onde u é o nome do objeto, picture é nosso campo de imagem, url retorna o endereço da imagem e :small é o tramanho que eu defini anteriormente.

Para esse exemplo os seguintes códigos também funcionariam:

<%= image_tag u.picture.url() %>
<%= image_tag u.picture.url(:small) %>
<%= image_tag u.picture.url(:large) %>

Concluindo.

Agora já temos nosso sistema funcionando com upload e redimensionamento de imagens atravéz do plugin Paperclip.

Digite:

$ script/server

para iniciar o servidor e acesse: http://localhost:3000/users

Resumindo.

Vou resumir o que se deve fazer para trabalhar com Paperclip:

Instalar o plug-in em seu projeto.
Criar os campos em sua model / tabela: sua_imagem_file_name (string), sua_imagem_content_type (string), sua_imagem_file_size (integer), sua_imagem_updated_at (datetime).
Definir, em seu model a propriedade has_attached_file com o nome do seu campo e estilos, se necessário.
Utilizar um formulário de cadastro com parâmetro multipart=>true e o campo tipo file_field.
Para exibir, utilizar o método url do campo de imagem passando por parâmetro o tamanho da imagem que foi previamente definido.

Bom pessoal espero que tenham gostado do post, qualquer dúvida postem um comentário ou me mandem um e-mail (está escrito no meu perfil do blog).

Abraços e até o próximo post!

Ruby Inside Brasil

2009-02-16T23:52:00.005-03:00

Vou fazer um post rápido antes de dormir para ajudar a divulgar uma iniciativa muito interessante que acabo de ler no blog do Carlos Brando (Nome do jogo).

Ele informa em seu post o lançamento de um novo canal de comunicação para a comunidade Rails brasileira que trará informações sobre as novidades do mundo Rails. Tanto as informações originais do Ruby Inside traduzidas para o português quanto artigos de desenvolvedores brasileiros sobre o tema.

Fiquem com o link, assinem o feed e bom proveito!

Ruby + Rails no mundo Real 2009

2009-02-13T20:31:00.008-02:00

Dia 04 de abril acontecerá o Ruby + Rails no mundo Real 2009 em São Paulo, será um evento bem interessante para os amantes do Rails.

Direto do site Guru-SP:

O primeiro grande evento das comunidades Guru-SP e Rails-BR apresentará algumas das mais importantes personalidades nacionais desse mercado com projetos e experiências reais.

O seminário falará sobre temas do dia a dia, como controle de versão, testes, treinamentos, servidores de aplicação e mercado de trabalho (tanto interno como externo).

Este evento também contará com a presença da equipe técnica da Sun Microsystems, apresentando como utilizar o servidor de aplicações GlassFish em aplicações Rails.

É um evento imperdível pra quem trabalha com desenvolvimento de software e quer conhecer mais sobre a plataforma de software que está mudando rapidamente o mundo.

Para saber mais detalhes sobre o evento visite a página do mesmo em Ruby e Rails no mundo real - primeira edição

Programação do evento:

08:30 as 09:00: Credenciamento
09:00 as 09:15: Abertura do evento (Marcelo Castellani)
09:15 as 10:30: Criando um Instant Messenger usando Rails (Vinícius Baggio)
10:30 as 10:45: Ruby, Rails e empreendedorismo (Hugo Borges)
10:45 as 11:00: Coffee break
11:00 as 12:00: Fabio Kung - a definir
12:00 as 13:00: Almoço
13:00 as 14:00: Outsorcing, ou como trabalhar para empresas gringas (Caffo)
14:00 as 15:00: GlassFish on Rails: Escalabilidade e Confiabilidade (Maurício Leal)
15:00 as 15:45: Testes em Ruby e Rails (Carlos Brando)
15:45 as 16:00: Coffee break
16:00 as 16:15: O que é e como funciona o RubyLearning (Willian Molinari)
16:15 as 17:15: Utilizando Gitorious nos seus projetos (Fábio Akita)
17:15 as 17:45: Desconferência
17:45 as 18:00: Encerramento

Faça sua inscrição no endereço http://www.temporealeventos.com.br/?area=130

O local do evento será R. Teixeira da Silva, 647 - Paraíso - São Paulo - SP (Century Flat Paulista).

Eu irei com certeza, já estou com a minha inscrição feita.

Abraços, até o próximo post!

Configurar teclado modelo americano para o alfabeto brasileiro no Ubuntu

2009-02-11T21:57:00.005-02:00

Hoje vou fazer um post rápido para falar sobre algo que me ajudou muito essa semana.

Comprei um laptop recentemente que possui o teclado com layout americano, suas teclas por padrão não trabalham com acentuação. Isso já estava me deixando louco quando ontem, no site do Viva o Linux, eu li uma dica ensinando como fazer isso.

A dica é do Eddie Hsu e o endereço original é http://www.vivaolinux.com.br/dica/Configurando-teclado-com-layout-americano-para-funcionar-simbolos-do-alfabeto-brasileiro/

Resumindo ela, para configurar faça o seguinte:

1) Vá em Sistema -> Preferências -> Teclado.

2) Acesse a aba "Disposições".

3) Selecione o modelo de seu teclado no item correspondente (o meu é Pc (Intl) Genérico de 105 teclas).

4) Em "Disposições selecionadas" selecione "EUA Internacional (com teclas acentuáveis)".

Pronto, está feito!

Ps. Se você deseja configurar esse teclado no Windows, o nome dele lá é "English (United States) - United States - International"

Editores de texto para Ruby on Rails no Linux - gedit e Emacs

2009-02-08T17:16:00.006-02:00

Hoje vou falar a respeito de dois editores de texto que, com algumas modificações, possibilitam um ambiente de desenvolvimento excelente em Rails no Linux, não sendo necessário o uso de IDEs como Netbeans ou Aptana RadRails. São eles o gedit e o Emacs.

Ruby on Rails é um framework onde tudo pode ser feito atravéz de linha de comando, sendo assim eu defendo a ideia de que você não precisa de mais do que um bom editor de textos para desenvolver em Rails.

Quando eu comecei a tentar fazer uns projetos com Rails eu estava utilizando o jEdit (editor que eu uso bastante para php), mas não estava totalmente satisfeito com a produtividade. Sempre ouvi falar do Textmate para Mac OS X, mas ainda não estou disposto a trocar de sistema operacional nem de computador.

Vou ensinar a vocês como instalar os editores que eu mencionei e falar um pouco a respeito deles.

Primeira opção: gEdit + gmate

O gedit é o editor de textos padrão do Gnome, se você usa uma distribuição Linux com ambiente gráfico Gnome então você provavelmente já tem ele instalado.

Vamos fazer algumas modificações nele para ele ficar mais adaptado ao Rails.

Primeiramente vamos instalar o pacote de suporte a plugins, caso ainda não esteja instalado. Utilize o comando:

$ sudo apt-get install gedit-plugins

Outra coisa importante para se programar num editor é o recurso "recuo automático". Ele faz com que, quando você estiver usando tabulações ou espaços para indentar seu texto e for para a próxima linha, o editor adicione automaticamente a indentação.

Para ativar essa opção abra o gedit e vá em:

Editar -> Preferências -> Editor

E marque a opção:

Habilitar recuo automático.

Agora vamos instalar o gmate, que é um conjunto de plugins selecionados pelo Alexandre da Silva para adaptar o gedit ao desenvolvimento de aplicações, principalmente em Rails. Para isso siga as etapas a seguir:

1 - Se você está utilizando Ubuntu instale os seguintes programas no console do Linux:

$ sudo apt-get install python-webkitgtk
$ sudo apt-get install python-pyinotify

2 - Ainda no console do Linux vá para sua pasta pessoal (/home/seu_nome, geralmente o console já abre nessa pasta).

3 - Digite o comando para clonar o arquivo:

$ git clone git://github.com/lexrupy/gmate.git

Ps. para isso você precisará ter o GIT instalado. Se você ainda não tem de uma olhada no post http://brunograsselli.com.br/2009/02/instalar-git-no-ubuntu.html

4 - Entre na pasta que ele criou:

$ cd gmate

5 - Digite o comando para sua instalação:

$ sh install.sh

Agora seu gedit já está com uma série de plug-ins instalados para o desenvolvimento Rails.

Um que é muito útil é o Painel do navegador de arquivos (Editar -> Preferências -> Plug-ins).
Ele exibe a árvore dos arquivos que estão em um determinado diretório (como o diretório do seu projeto, por exemplo).

Para exibí-lo basta ativá-lo na parte de plug-ins:

Editar -> Preferências -> Plug-ins

e ativar sua exibição em:

Ver -> Painel lateral

Com isso e os demais plug-ins você terá uma série de ferramentas a sua disposição.

Agora vamos a nossa segunda opção:

Segunda opção: Emacs + emacs-rails

O Emacs é um ótimo editor para Rails também. Ainda estou aprendendo como utilizá-lo mas ele já me surpreendeu com o pouco que eu vi.

Para instalá-lo você pode efetuar o download em http://www.gnu.org/software/emacs/

Caso você esteja utilizando um distribuição originada do Debian (exemplo: Ubuntu) você não precisa fazer o download, pode instalar a partir do comando:

$ sudo apt-get install emacs

Após instalá-lo vamos instalar o conjunto de plug-ins emacs-rails criado por Thiago Pradi, Ramon Soares e Marcos Zimmermann, para isso siga as etapas:

1 - Abra o console do Linux e vá para sua pasta pessoal (/home/seu_nome, geralmente o console já abre nessa pasta).

2 - Digite o comando para clonar o arquivo:

$ git clone git://github.com/tchandy/emacs-rails.git

3 - Entre na pasta que ele criou:

$ cd emacs-rails

4 - Digite o comando para sua instalação:

$ cp -r .emacs* ~

Pronto, agora você já tem o emacs adaptado para Ruby on Rails.

Para abrir o mesmo painel de navegação de arquivos que eu comentei no gedit no Emacs basta ir em:

Options -> Show/Hide -> Speedbar

Gostaria de agradecer ao nofxx, Fu e Patrick Spake da comunidade Ruby on Br, foram eles que me deram as dicas dos editores e me ensinaram como instalá-los.

Espero ter ajudado com o post, até o próximo!

Links relacionados:

How to Install GIT on Ubuntu (in English)

2009-02-04T21:11:00.012-02:00

From today I'll start to post some topics translated to English, to help more users.

Forgive my English, it isn't perfect but I hope it will do.

Today I'll make a quick post about how to install GIT on Ubuntu.
GIT is a software to handle and delivery versions of projects, it was made by Linus Torvalds for the Kernel's project and, nowadays, it is used for many other projects, such as Ruby on Rails.

When I posted about how to install Rails on Ubuntu I didn't mention GIT, but you'll realize that is very useful to have it installed because there are many plugins for Rails stored on GIT repositories.

To install it is very simple, you only have to use this command:

$ sudo apt-get install git-core git-doc git-svn git-gui gitk

In your journey in Ruby on Rails' world you will find many plugins that needs GIT for their installation, but it won't be a problem anymore.

See you!

Related links:

http://git-scm.com

Other languages:

Versão em Português

Instalar GIT no Ubuntu

2009-02-04T20:07:00.010-02:00

Hoje vou fazer um post rápido para ensinar como instalar o GIT no Ubuntu.
O GIT é um software para gerenciamento de versões de projetos, foi criado pelo Linus Torvalds para o projeto do Kernel do Linux e, hoje em dia, é utilizado por uma série de outros projetos, entre eles o Ruby on Rails.

Quando eu bloguei há uns dias atrás sobre a instalação do Rails no Ubuntu eu não comentei sobre o GIT, mas você vai perceber que é muito útil ter ele instalado pois existem muitos plugins para Rails que estão armazenados em repositórios GIT.

Para instalá-lo é bem simples, basta utilizar o comando:

$ sudo apt-get install git-core git-doc git-svn git-gui gitk

Ao longo de sua jornada pelo mundo Ruby on Rails você irá se deparar com vários plugins que necessitam do GIT para sua instalação, mas agora isso não é mais um problema.

Até o próximo post!

Links relacionados:

http://git-scm.com

Outros idiomas:

English version

Configurar banda larga 3G no Ubuntu 8.10

2009-02-01T13:21:00.005-02:00

Recentemente comecei a utilizar o serviço de banda larga da Claro 3G no meu laptop. Me surpreendi com a facilidade de configuração desse tipo de conexão no Ubuntu 8.10 Intrepid Ibex (digo isso pois tinha pesquisado a respeito da instalação em outras versões do Ubuntu e parecia um pouco trabalhoso).

Para configurar inicie o Ubuntu com o modem conectado à porta USB. Para verificar se o Ubuntu detectou o modem você pode utilizar o comando:

$ lsusb

Após iniciar o sistema clique sobre o ícone de conexão de rede que fica próximo ao relógio e selecione o item "configurar".

Abrirá uma janela e, após clicar em "Frente", te dará opções de país e operadora, basta selecionar a operadora desejada.

De um nome à sua conexão e conclua o processo.

Após isso a internet já deve estar funcionando! Para conectar basta clicar no item de conexão de rede novamente e selecionar o item da conexão que acaba de ser configurada.

Em alguns casos ocorre de ele estar conectado mas mesmo assim o Firefox não exibir as páginas. Isso aconteceu no meu caso. Para solucionar utilize o comando abaixo:

$ sudo gedit /etc/ppp/options

Esse comando abrirá um arquivo texto pelo gedit. No final desse arquivo adicione a linha:

ipcp-max-failure 30

Salve o arquivo e reinicie o micro, agora deve funcionar (no meu micro funcionou dessa forma, eu utilizo um modem Huawei E226).

Até a próxima pessoal!

Configurando regras de acentuação manualmente no Ruby on Rails

2009-01-27T21:14:00.006-02:00

O Ruby on Rails é um dos frameworks que mais aplica o paradigma Convention over Configuration em sua estrutura.

O intuito desse paradigma é fazer com que o programador só precise configurar (especificar) os aspectos da sua aplicação que não seguem a convenção da linguagem. Sendo assim se ele sempre seguir a convenção ele não precisa efetuar nenhuma configuração adicional.

Por exemplo, o Rails possui uma convenção de que classes devem possuir nomes no singular e, as respectivas tabelas no banco de dados, devem possuir o mesmo nome no plural. Se você criar uma classe House, o Ruby on Rails vai entender que a tabela correspondente para salvar os registros da classe House no banco de dados é a tabela Houses, no plural.

Caso você deseje utilizar uma tabela com outro nome para esse propósito, você terá que configurá-la manualmente. Mas caso você aceite a convenção do Rails e utilize o nome da tabela como Houses, então você não precisará configurar nada, apenas digite house.save e o Rails irá salvar o registro na tabela correspondente (bem mais prático).

O porque de toda essa explicação.

Para saber qual o nome da tabela correspondente no banco de dados, o Rails faz uso do método pluralize.

Esse método recebe uma string como argumento e retorna uma outra string com o plural da palavra recebida.

Faça um teste, abra o diretório do seu projeto pelo console do Linux / Mac e digite:

script/console

Isso abrirá um console parecido com o IRB, mas com todo o ambiente do Rails carregado junto a ele.

Nesse console digite, por exemplo:

"house".pluralize

"child".pluralize

"person".pluralize

Os resultados serão

"houses"

"children"

"people"

Viram, o Rails sabe trabalhar até com plurais irregulares do inglês.
Mas, como eu disse, o Rails só sabe trabalhar com inglês. Por exemplo, se você digitar "imagem".pluralize o resultado será "imagems" e não "imagens".

Meu objetivo nesse post é ensinar uma forma rápida de se configurar regras de pluralização em outras línguas no Rails.

É lógico que hoje em dia existem plugins / gems para o Rails que contém todas as regras de pluralização em português (Brazilian Rails), mas vamos dizer que você só precise de uma ou duas para um projeto ou um teste que você está fazendo. Vou explicar como fazer.

Configurando regras de pluralização.

O processo é bem simples, abra com um editor de texto ou IDE o arquivo que está dentro da pasta do seu projeto em:

./config/initializers/inflections.rb

Descomente as linhas:

ActiveSupport::Inflector.inflections do |inflect|

e

end

(Se elas não estiverem comentadas simplesmente digite-as).

Dentro deste bloco digite as regras que deseja. Dentro do arquivo inflections.rb existem alguns exemplos de regras (comentados). Segue uma de exemplo:

inflect.irregular 'imagem', 'imagens'

Seu arquivo deve ficar assim:

ActiveSupport::Inflector.inflections do |inflect|

inflect.irregular 'imagem', 'imagens'

end

Basta salvar e reiniciar o console (ou o servidor, depende de onde você estiver testando) e já estará funcionando.

Pessoal, espero ter ajudado, qualquer dúvida sintam-se livres para perguntar.

Dica de livro: Getting Real

2009-01-24T12:26:00.006-02:00

Recentemente fiz um curso sobre Ruby on Rails, onde me indicaram a leitura do livro "Getting Real" da 37signals.

Estou aqui para recomendá-lo a todos vocês pois o livro é realmente muito bom e agrega muito valor ao leitor, seja ele um programador, analista, designer ou até de uma área não relacionada a informática.

Ele fala a respeito de projetos, formação de equipes, entre outros. Sempre trazendo exemplos de casos similares bem sucedidos na área.

O livro é pequeno, possui versão em português gratuita no próprio site da 37signals, vale a pena dar uma olhada.

Para quem não sabe a 37signals é a empresa por trás da criação do Ruby on Rails, entre outros projetos. A empresa tem uma visão bem peculiar a respeito de projetos (opinionated), defende idéias como "Faça menos que a concorrência", ou "Comece com não".

Seguem links abaixo:

Getting Real - Versão Online em Português
Getting Real - Original Version

Instalar Ruby on Rails + MySQL no Ubuntu

2009-01-18T20:37:00.022-02:00

Post Atualizado em 30/04/2010, todos os dados estão atualizados.

Hoje estou voltando a postar no blog e, para iniciar o ano, vou começar a falar sobre uma linguagem diferente das comentadas aqui anteriormente, a linguagem Ruby junto com o framework Rails.

Este post ensinará como instalar o Ruby on Rails no Ubuntu, vamos lá!

Instalado o Ruby.

Para instalar o ruby utilizaremos os comandos abaixo, que devem ser digitados no console do Linux.

sudo apt-get install build-essential
sudo apt-get install ruby1.8 ruby1.8-dev rdoc1.8 ri1.8 irb1.8

Instalando o RubyGems.

O gems é um gerenciador de pacotes, que te ajudará a instalar facilmente diversas aplicações referentes a ruby, similar ao apt-get do debian.

Vamos utilizá-lo para instalar os próximos pacotes.

Para instalá-lo, digite o comandos:

wget http://rubyforge.org/frs/download.php/60718/rubygems-1.3.5.tgz
tar xvzf rubygems-1.3.5.tgz
cd rubygems-1.3.5/
sudo ruby1.8 setup.rb

Isso instalará a versão 1.3.5 do gems. Caso você deseje verificar se existe uma mais recente, você pode acessar o endereço:

http://rubyforge.org/frs/?group_id=126

Configurando links para o Ubuntu.

O apt-get do Ubuntu mantém os nomes dos pacotes que instalamos como: ruby1.8, gem1.8, rdoc1.8, ri1.8, irb1.8.

Esses nomes não são muito bons para se trabalhar, então vamos criar alguns links mais amigáveis. Utilize os comandos:

sudo ln -s /usr/bin/gem1.8 /usr/bin/gem
sudo ln -s /usr/bin/ruby1.8 /usr/bin/ruby
sudo ln -s /usr/bin/rdoc1.8 /usr/bin/rdoc
sudo ln -s /usr/bin/ri1.8 /usr/bin/ri
sudo ln -s /usr/bin/irb1.8 /usr/bin/irb

Atualizando o Gems.

Digite o comando abaixo para verificar se existe alguma atualização disponível para o rubygems:

sudo gem update --system
sudo gem sources -a http://gems.github.com
sudo gem sources -a http://gemcutter.org

Após instalar o gems execute o comando abaixo para verificar se existe alguma atualização disponível para ele:

Instalando o Rails.

Vamos utilizar o gems para instalar o Rails, para isso digite os comandos:

sudo gem install rails
sudo apt-get install libopenssl-ruby

Instalando o MySQL.

Utilizarei o MySQL como banco de dados em minhas aplicações Rails, seguem os comandos para instalá-lo:

sudo apt-get install mysql-server-5.1
sudo apt-get install libmysqlclient15-dev
sudo gem install mysql

Concluindo.

Com isso você já terá Ruby on Rails funcionando no seu Ubuntu.
Eu testei os comandos em diversas versões do Ubuntu e micros diferentes, dentre as versões estão: Ubuntu 8.10 (Intrepid Ibex), Ubuntu 9.04 (Jaunty Jackalope), Ubuntu 9.10 (Karmic Koala) e Ubuntu 10.04 (Lucid Lynx), mas acredito que em outras versões também funcione perfeitamente.
Se você testou em alguma outra versão por favor me informe, será de grande ajuda.

IDEs.

Muita gente defende que Ruby on Rails não precisa de IDE, e eu não sou totalmente contra esse idéia, mas se você deseja instalar alguma você tem várias opções, como por exemplo o NetBeans e o Aptana RadRails.

A instalação do NetBeans é um pouco mais fácil que a do Aptana (basta executar o instalador).

Se você optar pelo Aptana você deve baixar o Aptana Studio e depois instalar o plugin para manipulação de projeto Rails, para isso:

Menu Help -> Software Updates -> Find and Install -> Search for new features to install (selecione Aptana RadRails Development Environment.

Espero que o post ajude, qualquer dúvida entre em contato.

Visite também o post sobre a instalação do GIT no Ubuntu:
http://brunograsselli.com.br/2009/02/instalar-git-no-ubuntu.html

Os posts sobre editores de texto para Ruby on Rails:
http://brunograsselli.com.br/2009/02/editores-de-texto-para-ruby-on-rails-no.html

E:
http://brunograsselli.com.br/2009/04/vim-ruby-on-rails.html

Links relacionados:

Post Atualizado em 30/04/2010, todos os dados estão atualizados.

Multi-touch Whiteboard de baixo custo utilizando um Wiimote

2008-12-19T01:11:00.002-02:00

Saudações pessoal,

Esses últimos dias não estou conseguindo postar no blog pois estou no meio de um intercâmbio em Toronto, Canadá. Retornarei dia 28 de dezembro e acredito que conseguirei retornar aos tópicos sobre programação e desenvolvimento.

Estou passando para mostrar um vídeo que assisti há algum tempo atrás que é muito interessante. O vídeo mostra como interagir com uma imagem projetada na parede utilizando uma caneta e um joystick de Nintendo Wii.

Até breve, segue vídeo abaixo.

jEdit com a fonte embaçada / desfocada no Ubuntu

2008-11-25T23:04:00.009-02:00

Saudações pessoal,

O post que eu vou fazer hoje é sobre um problema bem específico que tive com o jEdit (ótimo editor de texto para linguagens de programação) recentemente, mas pode ser útil para quem esteja passando pela mesma situação.

Tive que reinstalar o Ubuntu na minha máquina e, quando instalei o jEdit, ele estava com a fonte fora de foco, impraticável para o uso. Estava como na imagem abaixo (clique para ampliá-la):

Da pra perceber bem pelos sinais de igual, e a própria interface do aplicativo está estranha.

Pesquisei na internet e encontrei uma solução no site oficial do jEdit.

O que estava acontecendo é que, apesar de eu ter instalado o jre 6 do java, o runtime que estava como padrão no meu Linux era o openjdk 6.

Se você estiver com esse mesmo problema, basta alterar o runtime padrão do java para uma compatível ao jEdit, para fazer isso basta utilizar o comando:

$ sudo update-alternatives --config java

E selecionar a runtime desejada digitando o número correspondente.

Se você ainda não tiver instalado nenhuma runtime do java compatível, você pode instalar a partir do comando (o jre 1.5 também é compatível):

$ sudo apt-get install sun-java6-jre

Com isso o problema deve resolver, e o jEdit ficará normal, como mostra a figura:

Até a próxima, espero ter ajudado!

Ps. se você ainda não usa o jEdit e ficou curioso, pode instalá-lo a partir do comando:

$ sudo apt-get install jedit

Links relacionados:

http://www.jedit.org

Layout CSS, Aula 3 - Alinhando um DIV a esquerda do outro

2008-11-19T15:10:00.014-02:00

Bom pessoal,

Depois de algum tempo, consegui gravar o último vídeo do nosso assunto sobre Layout CSS.
Neste post nós veremos como criar as DIV's internas. Veremos como alinhar uma DIV ao lado da outra e, também um truque muito usado em CSS chamado faux columns.

Bom, como de costume, vou deixar aqui no início o vídeo, para ajudar no aprendizado:

Bom, abaixo segue o código de onde nós paramos no último post (no primeiro post nós criamos a DIV principal e a alinhamos a esquerda e, no segundo, fizemos ela ocupar 100% da altura da tela):

Lembrando que basta clicar na figura para ampliá-la.

O que falta para chegarmos até o formato do site esperado são as 3 DIV's internas. Vou colocar novamente a imagem com o formato que desejamos montar:

Criando as DIV's Internas

Agora sim vamos continuar da onde paramos.
Primeiramente vamos criar três DIV's dentro da DIV principal. Seus id's serão "topo", "menu" e "rodapé".
Conforme figura abaixo:

Ps. Como o código já está grande, não posso mais colocá-lo inteiro dentro das figuras. Por isso estou numerando as linhas, para você saber que esse não é o código completo.

Agora irei definir uma altura para a DIV "topo" e uma borda (apenas na parte de baixo).
Para fazer isso adicionarei um novo bloco no CSS com o seletor #topo, conforme figura abaixo.

Agora vamos começar a criar o CSS para as DIV's "menu" e "conteudo".
Primeiramente, vou definir uma largura fixa para as duas (130 px) e uma cor de fundo para cada uma (#faa para o menu e #aaf para o conteúdo).

Como você pode ver as DIV's ficaram uma em cima da outra. Para corrigir isso vamos utilizar a propriedade "float", que fará com que cada uma delas flutue em relação a DIV principal. Vamos definir float: left para o menu e right para o conteúdo.

Agora cada DIV já está posicionada no seu respectivo lugar.
Vamos então definir uma largura para o menu e o conteúdo, para que cada um ocupe todo o espaço disponível para eles.

Como a DIV principal tem 600px, vou utilizar 130px para o menu e 469px para o conteúdo. Fazendo isso deixarei entre eles um espaço de 1 px, que eu utilizarei mais para frente.
Segue figura:

Agora vamos definir uma borda entre o menu e o conteúdo.
Para fazer isso, a técnica escolhida será o faux columns. Criarei uma imagem com a largura da DIV principal (600px) e apenas 1px de altura.
Farei com que essa imagem tenha fundo transparente e pintarei nela apenas 1 pixel preto, justamente na posição onde está sobrando um pixel vazio em nosso layout. Definirei essa imagem como fundo da DIV principal.
Sendo assim ela se repetirá e pintará uma borda entre as duas DIV's (menu e conteúdo).

Segue abaixo o código onde insiro a imagem como fundo da DIV principal:

Infelizmente, por falhas técnicas do blog, não está sendo possível fazer upload da imagem que utilizei como fundo. Mas basta você criar qualquer imagem de 600x1 px e pintar um pixel preto no lugar correto. Veja como fazer isso no vídeo, utilizando o GIMP.

Você verá que a imagem também ficará como fundo da DIV "topo", o que não é o que queremos.

Para solucionar isso basta colocar uma cor de fundo na DIV topo, como faço na figura abaixo (aproveitei também para retirar a cor do fundo do menu e do conteúdo).

Agora estamos perto de terminar.
O resultado já está bem parecido com o desejado, mas o texto ainda está muito próximo das bordas. Para solucionar isso adicionarei 10px de padding a cada uma das 3 DIV's internas.

Ao adicionar o padding você terá de remover 20 px tanto da altura da DIV topo, quanto da largura das DIV's menu e conteúdo, pois senão os novos tamanhos empurrarão a estrutura do nosso site.

Veja como ficou na figura abaixo:

Agora só falta ajustarmos um detalhe.
No último post sobre o assunto fizemos todo um trabalho para que o DIV principal acompanhasse o conteúdo do site caso ele fosse maior que a janela. Como utilizamos as propriedades float no DIV menu e conteúdo, eles não empurrarão mais a DIV principal (coloque bastante texto dentro do DIV conteúdo fazendo com que ele ultrapasse o tamanho da janela, na vertical, para conferir).

Para solucionar isso vamos fazer uma "gambiarra". Colocaremos depois da div conteúdo uma nova DIV chamada "rodape", que será invisível.

Colocaremos um novo bloco no CCS referente a DIV rodapé colocando a propriedade "clear" dela como "both".

Sendo assim a DIV invisível rodapé será posicionada abaixo do menu e do conteúdo e, como ela não tem float, ela empurrará a DIV principal!

Veja código abaixo:

E assim, finalmente chegamos ao resultado proposto!

Mais pra frente podermos criar um quarto post extra, ensinando a criar um rodapé de verdade, que fique posicionado sempre no fundo da janela.

Por enquanto é isso, espero ter ajudado!

Abraços!

Links relacionados:

http://www.youtube.com/watch?v=9TIGHvVwx18

Recuperar valor do auto incremento após efetuar INSERT com PHP e MySQL

2008-11-17T16:22:00.007-02:00

Saudações a todos,

As vezes quando temos uma tabela no banco de dados com um campo definido como AUTO_INCREMENT, precisamos recuperar esse valor logo após o INSERT (por diversos motivos).

Para isso não basta fazer uma consulta para recuperar o maior valor (MAX) do campo na tabela pois uma outra pessoa pode já ter feito um INSERT após o seu e o valor que o SQL retornará estará incorreto.

Para solucionar esse problema no PHP é bem fácil, utilizamos a função mysql_insert_id().

Ela retorna o ID gerado por um campo de auto incremento do consulta INSERT anterior.

Por exemplo, vou inserir um registro em uma tabela chamada pedidos e, após isso, exibir qual foi o número do pedido gerado:

<?php
$link = mysql_connect('localhost', 'mysql_user', 'mysql_password');

if (!$link) {
die('Não foi possível conectar: ' . mysql_error());
}

mysql_select_db('mydb');

$sql = 'INSERT INTO pedidos (item, valor) VALUES (2, 200.25)';

mysql_query($sql);

echo 'Número do pedido: ' . mysql_insert_id();
?>

Espero ter ajudado, qualquer dúvida poste um comentário ou me envie um e-mail (deixei meu e-mail disponível no meu perfil do blog).

Abraços.

Links relacionados:

http://www.php.net/mysql_insert_id

Copiar e colar textos no console do Linux

2008-11-07T21:34:00.004-02:00

Saudações pessoal,

Sei que estou devendo o terceiro post do assunto sobre o layout CSS, devo estar postando ele nos próximos dias.

Hoje vou fazer um post rápido que pode ser útil. Em algumas distribuições do Linux as teclas de atalho CTRL + C e CTRL + V não funcionam no console (Shell). Até existem teclas de atalho específicas para isso, mas variam em cada distribuição.

Existe um jeito de copiar e colar texto no console do Linux (e também nos demais aplicativos dele) que funciona na maioria das distribuições. Para isso basta selecionar o texto desejado e clicar sobre ele com o botão do scroll do mouse (com isso você copia o texto) e, para colar, basta selecionar o local desejado e clicar novamente no botão do scroll. É um jeito simples e prático de se trabalhar no Linux.

Lembrando que nem sempre o texto copiado pelo CTRL + C pode ser colado a partir do botão de scroll, e vice versa, pois cada comando utiliza uma área diferente para armazenar a informação. Mas o texto copiado pelo botão do scroll sempre pode ser colado pressionando o scroll novamente.

Espero que a dica seja útil.

Abraços!

Atualizar Ubuntu 8.04 para 8.10

2008-10-30T23:17:00.003-02:00

Pessoal,

Foi lançada a nova versão do Ubuntu (Ubuntu 8.10) no site http://www.ubuntu.com.

O Ubuntu 8.04 não dará a opção de atualizar versão por padrão, então, para atualizar o seu Ubuntu 8.04 para a versão 8.10, faça o seguinte:

Acesse no menu:

Sistema -> Administração -> Canais de Software

Acesse a aba "Atualizações" e mude a opção "Atualização de lançamento" para "versões normais".

Feche e acesse no menu:

Sistema -> Administração -> Gerenciador de atualizações

A opção de atualizar para a versão 8.10 aparecerá para você.

Abraços, espero ter ajudado!

Layout CSS, Aula 2 - Altura do DIV ocupando 100% da página

2008-10-25T20:11:00.010-02:00

Saudações,

Vamos dar continuidade à criação de uma estrutura para uma página web utilizando CSS.

No último post nós criamos a DIV principal e alinhamos no centro da página.
Agora vamos fazer com que essa DIV ocupe 100% da página na vertical.

Segue abaixo um vídeo que eu criei explicando, na prática, como fazer.

Agora vou explicar passo a passo como foi feito.

Onde paramos.

Bom, para relembrar, o Layout da página web que estamos tentando montar com CSS seguirá a estrutura abaixo:

O código até onde nós já fizemos é o seguinte:

Como dito antes, nós já temos a DIV principal e ela já está alinha no centro da página.

Para utilizar o CSS de forma mais adequada, eu substituí o parâmetro "class", do tag DIV por "id". Pois como o CSS que será definido para a DIV principal será utilizado apenas nela, podemos então usar id.

Para fazer essa alteração, tive que alterar, também, o seletor "." (ponto) do CSS por "#".

Conforme figura abaixo:

Definindo a altura da tag.

Para definir a altura de uma tag utilizamos a propriedade height (altura).
Em tese, tudo que deveríamos fazer para nossa DIV principal ocupar 100% do navegador seria colocar sua propriedade height como 100% (height: 100%;).
Mas isso não será o suficiente, vou explicar o porque.

Ao utilizar porcentagem como parâmetro para a propriedade height, estamos definindo o quanto da altura da tag pai estaremos ocupando.
Se você reparar, a tag DIV está dentro da tag BODY, que por sua vez está dentro da tag HTML. Então height: 100% na tag DIV quer dizer que ela utilizará toda a altura disponível dentro da tag BODY.
Como a tag BODY não tem uma altura definida, ela recebe por padrão o valor "auto", que quer dizer que ela usará a altura necessária para envolver os textos, imagens, etc dentro de suas tags filhotes. Portanto, a tag DIV não conseguirá utilizar muito espaço dessa forma.
Para chegar ao resultado que queremos devemos definir, além da tag DIV, a altura da tag BODY e da tag HTML como 100%, assim a tag DIV conseguirá utilizar 100% da página.

A figura abaixo ilustra essa situação:

E essa outra figura demonstra como ficou o código até agora, com as tags HTML, BODY e DIV (id='principal') com altura 100% (inseri cores de fundo para ficar mais fácil a visualização e bordas esquerda e direita, retirei a borda total):

Definindo a altura mínima (min-height).

Nosso código já está bem próximo do efeito esperado, mas ele ainda possui uma falha (que não será percebida se você estiver utilizando Internet Explorer 6 ou inferior).

Se digitarmos muito texto dentro da tag DIV a ponto de que o texto exceda a altura dela, perceberemos que o navegador expande sua área de visualização mas a tag DIV não acompanha, então parte do texto ficará fora da tag.

Para fazer com que a altura da tag DIV acompanhe o texto dentro dela, precisamos definir a propriedade height da tag DIV principal como "auto" (height: auto;).
Mas, ao fazer isso, nossa tag deixará de ocupar 100% da altura do navegador.

Para fazer com que ela volte a ocupar 100% do navegador e continue acompanhando o texto caso ele seja maior do que ela, podemos utilizar a propriedade min-height (altura mínima).

Se definirmos min-height: 100% e height: auto estaremos fazendo com que a tag DIV ocupe, no mínimo, 100% da altura inicial e, caso o texto ultrapasse essa altura, ela o acompanhe.

Seria perfeito se não fosse pelo fato de que o Internet Explorer não reconhece, ainda, a propriedade min-height do CSS (a maioria dos demais navegadores já trabalham com ela).

Para solucionar o problema eu encontrei dois métodos.

O primeiro seria utilizar a propriedade _height: 100%;
Que funciona como uma espécie de hack para adicionar altura mínima no Internet Explorer. Mas eu ouvi comentários de que essa propriedade não é reconhecida pelo W3C, então você não conseguirá validar seu código CSS se estiver utilizando ela.

Outra seria utilizar o código abaixo:

* html #principal {
height: 100%;
}

Que define altura como 100% apenas para o navegador Internet Explorer. Parece que existe uma convenção de que, ao utilizarmos o seletor "* html" estamos nos referindo a propriedades que só serão utilizadas pelo Internet Explorer.

Bom, sendo assim, segue abaixo nosso código final:

Bom, por enquanto é só.
Já temos nossa DIV principal alinhada no centro da página e utilizando 100% da altura disponível no navegador.
No próximo post sobre o assunto faremos as DIV's internas, ensinando como alinhar uma ao lado da outra e, também, utilizaremos a técnica chamada faux columns.

Até lá!

Links relacionados:

http://www.youtube.com/watch?v=Acw53GhX3Tg

Layout CSS, Aula 1 - Como alinhar um DIV no centro da página

2008-10-20T22:46:00.011-02:00

Saudações,

A proposta nesse tópico é ensinar como criar um layout simples para uma página web utilizando CSS.
O resultado final será um layout com uma estrutura similar a da figura abaixo:

Onde temos um espaço na parte superior para o logotipo, outro na parte inferior esquerda para o menu e outro para o conteúdo.

Para fazer isso utilizarei três posts, cada um com um assunto específico.

O assunto deste primeiro post será "Como alinhar um DIV no centro da página".
Onde criaremos o DIV principal que conterá toda a estrutura do site dentro dele.

Para ajudar no entendimento gravei um vídeo, mas mesmo assim vou colocar abaixo as instruções passo a passo, pois nem sempre da pra ler no vídeo os textos.

Segue abaixo o vídeo:

E agora vamos ao tutorial:

Criando a estrutura básica.

Primeiramente eu criei a estrutura simples de um HTML e inseri um DIV com a classe 'principal' dentro do corpo da página (body).
Criei um CSS para se referir a esse DIV adicionando borda e largura a ele, o código ficou assim:

Eliminando espaços entre o DIV principal e o corpo da página.

Com isso já temos o DIV, vamos agora ajustar a margem do corpo da página para não haver espaço entre o DIV e o BODY.
Para isso vou adicionar um novo bloco CSS, definindo a margem para a tag body como 0px.
Conforme figura abaixo:

Agora tudo que nos resta fazer nesta primeira lição é alinhar o DIV no centro da página.

Alinhando o DIV no centro.

Para isso. em alguns navegadores, basta definir o tag body com text-align igual a center.
Isso funciona em algumas versões do Internet Explorer, segue exemplo na figura alinhei o texto dentro do body como centralizado e, dentro da tag div, tornei a alinhá-lo a esquerda):

O código acima ainda não funciona em alguns navegadores, para solucionar esse problema o truque será adicionar margens automáticas ao div principal (margem esquerda e direita), como mostra a figura abaixo:

Pronto!
Com isso já teremos nosso DIV alinhado no centro da página!

Por enquanto vou ficando por aqui, espero ter ajudado!
Criarei mais dois posts sobre o assunto para concluir a estrutura do layout mencionada no começo do tópico, serão eles:

Layout CSS, Aula 2 - Altura do DIV ocupando 100% da página
Layout CSS, Aula 3 - Alinhando um DIV a esquerda do outro

Até lá!

Links relacionados:

http://www.youtube.com/watch?v=Hwm4icfhhvw

Configurar Ubuntu 8.04 para resolução 1024 x 768

2008-10-19T23:26:00.004-02:00

Saudações mais uma vez,

Quando instalei o Ubuntu pela primeira vez (versão 7.04) não havia conseguido configurá-lo para trabalhar com a resolução 1024 x 768 do monitor.
Quando lançou a versão 8.04 instalei ele de novo e, novamente, a máxima resolução que eu conseguia era 800 x 600.

Tentei alterar o arquivo xorg.conf e também utilizar aquele comando que configura uma série de dispositivos via shell mas nada feito.

Foi então que encontrei em um fórum um comando que solucionou meus problemas, portanto, se você está enfrentando a mesma situação, tente o seguinte comando para configurar a placa de vídeo e o monitor:

# sudo displayconfig-gtk

No meu caso, foi só ajustar o monitor e a opção de 1024 x 768 já ficou disponível.

Segue abaixo o link onde consegui o comando:

http://ubuntuforum-br.org/index.php?topic=35834.0

[]s!

Ubuntu 8.10 será lançado em breve

2008-10-18T18:16:00.002-03:00

Saudações a todos,

Estava dando uma olhada em alguns sites na internet e descobri que dia 30 de outubro será lançada a nova versão do Ubuntu! O Ubuntu 8.10.
Já está disponível a versão beta para download no endereço:

http://www.ubuntu.com/testing/intrepid/beta

Vou aguardar ansiosamente pela versão final!

Enquanto isso, coloquei o contador com a contagem regressiva para o lançamento no menu do blog. Faça isso no seu site também e ajude a divulgar, acessando o endereço:

http://www.ubuntu.com/getubuntu/countdown

[]s!

Open Hack 2008 - Yahoo! Brasil

2008-10-16T20:46:00.008-03:00

Dias 8 e 9 de novembro vai acontecer no Centro Universitário Senac, campus Santo Amaro (SP), o Hack Day da Yahoo! Brasil.

Segue abaixo texto do panfleto:

"O que é?

O Yahoo! Open Hack Day é um encontro de desenvolvedores e estudantes de TI promovido pelo Yahoo! Brasil.
Durante dois dias sem intervalos, os participantes estarão reunidos em uma grande celebração para exercitar suas mentes, criar novos aplicativos e serviços baseados nas plataformas do Yahoo! e ampliar suas redes de contatos.

Serão 24 horas seguidas de muito trabalho e diversão que vão premiar os autores dos melhores projetos e quatro categorias:

BOSS:
Plataforma aberta de web services do Yahoo! Search para você construir produtos de busca com base na indexação do Yahoo!
SEARCHMONKEY:
Nova plataforma aberta do Yahoo! Search, para você usar dados estruturados, conhecidos como micro formatos, e tornar os resultados do Yahoo! Search do jeito que você quiser.
YAHOO! BLUEPRINT MOBILE:
Plataforma de criação de widgets para celulares com suporte a múltiplos dispositivos e sistemas operacionais.
CATEGORIA LIVRE:
Use a imaginação e crie um projeto inovador usando os recursos de todas as plataformas do Yahoo!"

Esse evento é inédito na América Latina.

Endereço: Av. Engenheiro Eusébio Stevaux, 823 (altura do número 22.200 da Av. Nações Unidas).

Inscreva-se em HACKDAY.ORG.

Sites relacionados:

Configurando o GRUB, gerenciador de boot do Linux

2008-10-14T21:46:00.007-03:00

Bom, vamos dizer que você instalou o Linux mas gostaria que o Windows ainda ficasse como a opção padrão na hora de iniciar o computador (boot).

Na maioria das distribuições Linux, o programa que é utilizado para gerenciar a inicialização do computador (qual sistema irá iniciar, etc) é ou o GRUB, ou o Lilo.
Nesse post vou mostrar como configurar a tela de menu do GRUB (imagem abaixo).

Para editar a tela de menu do GRUB é bem simples, basta editar o arquivo (precisará de permissões de administrador):

/boot/grub/menu.lst

Para isso, basta usar qualquer editor de texto, por exemplo:

# sudo gedit /boot/grub/menu.lst

Ou

# sudo vim /boot/grub/menu.lst

No final desse arquivo você encotrará blocos de texto como estes:

title Microsoft Windows XP Home Edition
root (hd0,0)
savedefault
makeactive
chainloader +1

title Ubuntu 8.04.1, kernel 2.6.24-19-generic
root (hd0,2)
kernel /boot/vmlinuz-2.6.24-19-generic root=UUID=78c2a245-185e417e-8871-d5e3d6f6e4e7 ro quiet splash locale=pt_BR
initrd /boot/initrd.img-2.6.24-19-generic
quiet

Para alterar a ordem de exibição dos itens do menu basta trocar a ordem deles no arquivo.

Para escolher qual sistema operacional será o padrão na hora da inicialização você tem duas opções:

A primeira é escrever a linha "savedefault" no sitema operacional desejado. Como estava no exemplo que eu coloquei acima.

A segunda opção é alterar, la no começo do arquivo, a linha:

default 0

Colocando o número do item que deseja definir como padrão (lembrando que a contagem começa do zero).

Nesse arquivo você pode configurar também o tempo padrão para exibição do menu (em segundos), alterando o valor na linha (está localizada, geralmente, no começo do arquivo):

timeout 10

Após efetuar as alterações desejadas, basta salvar o arquivo (lembrando que é bom sempre fazer um back-up antes de alterar um arquivo de sistema).

Espero ter ajudado,

[]s.

Converter inteiro para hexadecimal em java

2008-10-11T23:20:00.008-03:00

Há uns tempos atrás eu estava criando um programa e precisava obter a representação hexadecimal de um número inteiro, perguntei em um fórum e as soluções que me deram eram um tanto quanto trabalhosas.

Hoje eu encontrei em um livro para certificação scjp uma solução muito simples para este problema. Na verdade, duas.

Existem dois métodos estáticos das classes wrapper Integer e Long que podem te ajudar nessa tarefa, são eles:

Long.toString(255, 16);

Long.toHexString(255);

Ambos retornam um String com a representação hexadecimal do número inteiro (ou long) informado. Como eu informei o inteiro 255 eles me retornarão "ff";

No caso do método toString() do exemplo, ele recebe dois parâmetros, o primeiro é o número inteiro que você deseja obter a representação em String e o segundo é a base.
Outro exemplos utilizando esse método:

long numero = 16l;

//Base 2 - Binária
System.out.println(Long.toString(numero,2));

//Base 8 - Octal
System.out.println(Long.toString(numero,8));

//Base 10 - Decimal
System.out.println(Long.toString(numero,10));

//Base 16 - hexadecimal
System.out.println(Long.toString(numero,16));

Bom, espero ter ajudado, eu sei que essa dica não é útil pra muita gente, mas se alguém estiver se deparando com esse mesmo problema essa solução pode ajudar.

[]s.