Programa para criar diagramas no Linux

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

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

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

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

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

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!