Archive for the ‘python’ Category

Não sejamos tão radicais…

junho 16th, 2010

Uma das coisa que me incomodam bastante no meio de informática é que muitos de nós são um tanto radicais. Canso de escutar pessoas dizerem que somente a tecnologia delas  – que elas usam – é a melhor. Em minha humilde opinião, comentários a parte (já escrevi, inclusive, sobre isso), não existe o ideal e a tecnologia mais adequada para o problema.

Como disse antes não quero me ater a discussão do porque não existe uma tecnologia legal e se devemos conhecer mais de uma pois isso, já amplamente abordado inclusive por mim.  Quero apenas rebater um poucos os fanáticos.

Atualmente temos uma clara evolução do uso de duas tecnologias principalmente: Python e Ruby. O Ruby quase exclusivamente impulsionado pelo Rails ( framework de desenvolvimento altamente produtivo de aplicativos web) e python pelo seu poder ( o famoso battery include) e também por alguns de seus frameworks ( Django, Web2Py, Zope, Plone, etc)

Uma coisa que me incomoda um pouco na galera é que por muitas vezes, o pessoal que está chegando agora, vem tomando logo formas de pensar radicais. Um exemplo disso é o discurso mais do que batido que Java é mal.

Gente, sinceramente, Java não é mal. Muito pelo contrário, foi uma grande porta, primeiro passo, para todo esse boom que temos visto. Java, embora não seja  opensource, sempre fomentou o software livre e acabou por criar uma comunidade forte em seu entorno. Essas mesmas comunidades  que são veneradas por  muitos dos que negam o java,  surgiram desse movimento graças ao Java.

O grande problema, da linguagem,  que ela parou no tempo. O que por um bom tempo, sobre somente alguns pontos de vista, ajudou a protegê-la foi o mesmo que a engessou-la. Se ela tivesse se aberto para modificação, mesmo que gradualmente, possivelmente  ainda estaria sendo usada e adorada como antes.

É certo que criar um aplicação em rails é muito mais produtivo do que criá-la em Java ( mesmo com todos os frameworks existentes).  O mesmo vale para o Python em até outros casos.  Então por que estou, aparentemente, defendendo-a? Simples, pois quero mostrar que ainda existe vida após a morte nesse nosso mundo de TI.

Java , para “competir”  com essa galera tem “renascido” com outras formas que permitem sermos mais produtivos.  Um exemplo que gosto muito é o Groovy. O Groovy, senão me engano, foi criado por 2002 ou 2003 como uma linguagem alternativa para rodar dentro da JVM (java virtual machine). Graças ao seu sucesso foi implementada a um especificação para tornar a JVM capaz de entender outras linguagens.

Groovy é um Java melhorada e evoluído para os moldes desses novos paradigmas trazidos por Ruby, Python, etc.  Trouxe uma produtividade maior. Hoje é possível fazer uma aplicação nos moldes de Rails em “Java” /groovy usando o framework Grails.

Outra faceta desse mesmo ponto de vista tem sido o JRuby. JRuby é uma implementação do interpretador do Ruby para a JVM. Assim é possível executar código escrito em Ruby a partir da JVM.

A coisa não para por aí. Basta uma simples busca no google para vermos outros exemplos desse renascimento em outras formas do Java.

E ainda tem a pŕopria linguagem que não para de evoluir e ainda tem o seu espaço. Acredito sinceramente, que existem alguns problemas (requisitos)  os quais a melhor solução seja implementar a solução em Java.

Bom com certeza ainda terão aqueles que dirão que suas linguagens tem as melhores ferramentas. Concordo plenamente. Para mim, falando por exemplo de testes – TDD e BDD,  cucumber, rspec, mocka, should-dsl, lettuce, entre outras são estado da arte. Porém, já encontrei coisas em “Java” (entenda aqui conseguir testar código java, pois tem ferramenta em Groovy por exemplo) que pelo menos chegam perto disso.

Bem a princípio era isso que gostaria de dizer, até a próxima pessoal.

“martelo é para pregar e não apertar parafusos”

abril 11th, 2010

Uma das coisa que escutei e sempre repeti por realmente acreditar que faça sentido é que, existe a ferramenta certa para cada tipo de trabalho.  Não adianta acreditar que aquela “paradinha” maneira que você conhece de “traz para frente”  vai ser a melhor solução para todos os seu problemas, pois simplesmente como uma verdade absolut, ela não será e quem a criou sabe disso. Note que eu disse – “não será a melhor opção”- e não = “não resolverá ou não fará”.

Acredito que todas a novas linguagens são capazes  de resolver a grande maioria de nossos problemas computacionais atuais.  Em raríssimos casos poderemos apenas usar uma determinada linguagem…muito mais por requisitos de processamento, velocidade e etc do que capacidade daquela linguagem. Falo isso, pois cansei de ouvir gente dizer que a linguagem B não é capaz de fazer o que a linguagem C faz. Ela faz sim, só que de uma forma mais complexa ou mais verbosa, por exemplo.

Sei que tocar nesse assunto é meio “chover no molhado” por ser este um tema muito falado e batido, porém, gostaria de dar uma visão real disso.  Imagine você numa situação em que precisar fazer um sistema. Este sistema possui várias facetas: uma parte para cliente, outra que ficará com um processamento em batch (background), etc. Já tive requisitos como estes em diversas oportunidades e em cada uma delas foi uma solução adotada.  Posso dizer que o pior dos casos foi quando tentamos usar a mesma “estrutura” para tudo.

Imagine que agora você comece a aplicação para os requisitos acima e faça tudo dentro de um servidor de aplicação. Aquela típica solução Java, onde um dentro do JBoss ou outro esteja tudo… Ali estão a lógica do sistema web, os processamentos em batch agendados via Quartz, etc.  Imagine também que isso tudo estará dentro de um servidor Linux (qualquer distribuição que seja)  - coisa bem factivel.  Dái começo a colocar algumas perguntas:  se todo sistemas linux tem um Cron (serviço de agendamento) por que usar algo feito em java para fazer a mesma coisa? Se argumentarem que é para garantir a independencia de plataforma, pergunto qual são as reais possibilidades de mudar a plataforma (SO, etc) ?  Com certeza que bastante remotas.

Esse tipo de coisa pode ser ainda mais extrapolado. Imagina agora que dentro do seu sistema é preciso processar diversos conteúdos de arquivos e importar seus dados para a base de dados do sistema. Muito fariam uma classe para que você fizessem um upload e processar. Mas não seria mais interessante deixar que alguém carregue via ftp e um processo agendado trate-o depois. Esse processo poderia ser algo escrito em bash mesmo pois será ultra rápido em comparação a uma aplicativo java. Mais uma vez aqueles xiitas diriam que seria para manter a questão da independencia de plataforma, mas quantas vezes sua web app mudou de servidor (SO, hardware, etc) nos últimos anos?

Se ousarmos um pouco mais, dada as recente evoluções da JVM (Java Virtual Machine)  as possibilidades vão além de usar o sistema operacional. Hoje é possível escolher em qual linguagem irá escrever cada parte de seu sistemas e estas coexistirem sem nenhum problema.  Antes que pensem que isso é um discurso de incentivo ao uso de Java, linguagem da qual gosto, estou usando esse ela como exemplo por ser um bom exemplo de como isso funciona e tem sido alvo de investimento.

Famosos produtos tem usado uma “tecnologia” para fazer a parte de integração com usuário e outra para fazer toda a parte de Kernel do sistema. Acredito que o Twitter seja um exemplo disso, pois sua parte de interna foi toda reescrita em Scala (nova linguagem objeto- funcional da JVM) .

Voltando a parte prática da coisa, um exemplo de  que é bom conhecer diversas ferramentas e saber empregá-las, é um caso num empresa que era preciso fazer medições de audiência em páginas. A solução inicial era de conteúdo dinamico em todas as páginas que quando acessadas iriam no servidor e gravavam um dado no banco de dados. Essa solução embora resolvesse o problema, ela acabava por onerar por demais o processamento pois tal parte não poderia ser posta em cache e a cada acesso, haveria uma requisição no servidor e um acesso ao banco de dados. O pessoal então passou para algo mais hibrido e pouco ortodoxo para época:  fez uma modificação para que o servidor colocasse no arquivo de log os dados de quem estava acessando e construiram um programa em shell para analisar esses logs. Com isso, embora não tivessemos um “tempo real” dos acessos, para os nosso requisitos de estatísticas serviu perfeitamente e reduziu a carga e o processamento, deixando para uma outra tecnologia que lida melhor com busca via regex fazer o trabalho dela.

Essa solução não sei se funciona ainda, acredito que com saida da terceirizada que fez da empresa tenha sido tirado,  mas foi uma marca para me mostrar que existem outras possibilidades além daquela que eu sabia na época. É isso que conta. E num mundo cada vez mais competitivo é importante ter mais de uma “carta na manga”.

Bem até a próxima pessoal.

Pyccuracy – Uma boa ferramenta de teste. Coloque-a na sua maleta

março 12th, 2010

Ultimamente, no meu emprego atual, tenho a oportunidade de usar um excelente framework de testes de aceitação brasileiríssimo que é o pycurracy . Ele é uma ferramenta feita em python que permite que você escreva suas histórias de aceitação em linguagem natural. Isso significa dizer, que você pode escreve o seu teste em português.

Não preciso dizer o quanto isso traz de vantagem. Só para citar, uma das mais imediatas, pelo menos para mim, é a questão da documentação.  Quem já está na estrada um tempo, sabe como é uma verdadeira luta manter documentações atualizadas do produto.  Tudo sempre começa bem, mas com o passar do tempo, sempre surgem outras tarefas mais urgentes e os “casos de uso”  ou histórias acabam ficando não condizentes com a realidade da aplicação.  Para muitos, isso pode soar como preciosismo porém imagine um contexto de um projeto open source… sem uma documentação bem feita, colaborar pode ficar bem difícil.

Um outro aspecto também é que desenvolvedores “não são muito amigos” de escrever documentos. Esta aí uma tarefa que vejo poucos colegas fazerem com prazer. Se puderem evitar, a grande maioria em minha humilde opinião,  evitarão fazê-lo.

Ferramentas como o pyccuracy, vem unir o “útil ao agradável”: vem possibilitar escrever testes, programando, e como resultado indireto obter uma excelente fonte para consultas.  Por permitir escrever os cenários  em linguagem natural (inglês e português) acabamos por ter um documento descrevendo o funcionamento esperado… as nossas histórias.

O pyccurace é todo feito em python usando o Selenium .  Para maiores detalhes recomendo uma visita a página do projeto.

A única coisa que tenho a dizer sobre ele é que bem que poderia ter uma implementação que usasse o WebDriver ao invés do Selenium RC. Acredito que ficaria bem mais rápido. Mas, até agora só temos versões estáveis do WebDriver para Java. A versão python está bem timida ainda.

Entendendo os decoradores em Python – Parte 1

dezembro 4th, 2009

A um certo tempo atrás me deparei com alguns códigos que usavam o recurso de decorator.  Dali, curioso com tal coisa, resolvi pesquisar para entender melhor como funcionam, para que servem, e quais seriam bons cenários para usá-lo.  Para minha surpresa, achei pouco material sobre, a maioria conteúdos que tratavam do assunto de forma superficial, outros que abordavam a coisa mais prática e/ou associada a um problema único,  alguns tantos falavam de forma extremamente complexa e sem muito nexo, etc. Para piorar,  quase nenhum dos artigos eram em português o que, se não tiver fluência total no inglês,  fica bastante complicado captar alguma essência (textos mal escritos, vocabulário difícil, e outras coisas).

Bem, desses todos, achei um excelente texto de uma fonte altamente confiável: Bruce Eckel, no site Artima.  O artigo aborda justamente de forma abrangente o assunto, decorator do python, e dando o enfoque que procurava (funcionamento, porque usar, como usar, quando usar) .  Então, como forma de dar minha retribuição a comunidade, segue uma versão do texto dele (não me ative a traduzir, parte irei reproduzir, outras colocarei minha visão).

Primeira coisa que considero interessante, que o próprio original cita,  é que necessitamos desfazer alguns conceitos erróneos sobre Decoradores. Muita gente quando escuta decorators logo remete seu pensamento aos padrões de projeto, mais precisamente, o padrão Decorator.  Esse padrão é feito para possibilidade de forma simples adicionar  recursos, detalhes, adornos a uma classe, inclusive em tempo de execução. Aqui eles tem mais uma carinha de Macros, do que decoradores.

O objetivo das macros é de permitir alterar os elementos de uma linguagem. Isto é exatamente oque os decoradores em Python fazem – eles modificam  funções e classes inteiras (existem decorators para classes) .  Isso é porque eles usualmente provem um caminho alternativo ao uso de metaclass.

A grande parte das linguagens que suportam tal recurso (auto-modificação)  falham no quesito complexidade :  elas são tanto restritivas e requerem, em alguns casos, uma linguagem diferente. Python se faz a pergunta: porque não fazê-lo em python mesmo? Porque não permitir escrever macros ou decoradores na própria linguagem permitindo uma interação maior ? Esse é exatamente a proposta dos decoradores.

Porque usar Decorators?

Decorators permitem que se altere a execução de um método ou classe. Para que os conhecem, lembra bastante o AOP (Aspect Oriented Programming – programação orientada a aspecto) .  A diferença que não precisamos muitas coisas ou grandes conhecimentos, oque torna muito interessante e legal, mesmo que para iniciantes.

Um exemplo de uso, didático,  é escrever algo que permita fazer algo antes e depois da execução de uma função.

1
2
3
@meuDecorator
def funcaoQualquer():
print "Ola Mundo"

A clásula acima @, define a chamada ao meu decorator que irá fazer algo, quando este método for chamado. Algo semelhante a uma proxy.

Existe uma escolha perfeita?

novembro 18th, 2009

Ultimamente é mais do que batido famosos artigos comparando linguagens e com conclusões um tanto radicais do tipo : “A linguagem B é melhor que C pois é mais produtiva”; “A linguagem P não escala”; “A linguagem Z é mais fácil e tem tudo que é necessário já integrado”; etc.  As questões que coloco frente a essas publicações são: Existe escolha perfeita ? Será que os contextos usados são justos, ou seja, permitem uma comparação em igualdade? Dá para comparar ou isso é apenas uma discussão como “sexo dos anjos”? Recentemente a discussão ganhou mais força com uma recente divulgação, não oficial, de que os desenvolvedores da Google estão sendo desencorajados a usarem Python em novos projetos [1]  .Na troca de emails, a decisão é justificada no fato que, o senso comum dentro da empresa acredita que o Python, dado o crescimento e escala das aplicações atuais, não responderia de forma satisfatória.

Java foi inventada na década de 90 (sua primeira versão foi por volta de 1995) e sua origem é bastante interessante e pouco conhecida do público em geral.  Java, antes chamada por Grosling de OAK (Carvalho em inglês), foi criada com objetivo permitir a comunicação entre diversos equipamentos, que não somente o computador. Nesses projeto, a intenção não era de criar um nova linguagem e sim uma tecnologia de convergência. Por um capricho do destino, as empresas não gostaram tanto e não compraram a ideia.

Nesse mesmo período a internet começava a se tornar o sucesso de hoje.  Com um crescimento rápido e em pouquíssimo tempo uma grande interativa estava se formando. Era exatamente este tipo de conectividade que a equipe de Grosling propunha. A ligação foi imediata e partiram para adaptar a OAK para esse novo possível uso. Assim nascia a primeira versão de Java. Ela foi totalmente concebida dentro do objetivo de “trafegar” em ambientes heterogêneos. Seu primeiro momento de sucesso veio do uso dos Applets (aplicações java que rodavam dentro do navegador através de uso de plugin) que deu um tom dinâmico ao, até então, estático hiper texto (html).  Daí por diante a adoção e crescimento do Java foi meteórico e hoje temos esse cenário onde ela é a principal tecnologia usada por grandes empresas em seus sistemas.

O interessante dessa história, é que durante muito tempo do início da linguagem, Java era considerada ruim. Isso mesmo ruim: muitos afirmavam que sua natureza multi-plataforma, sendo interpretada, a tornava lenda e muito pesada, pois consumia muita memória dos pobres PCs da época (antigamente memória e disco eram caros). Não foram poucos artigos escritos que afirmavam que, num ambiente corporativo, Java jamais seria aplicável  pois sobrecarregava demais o equipamento e não era escalável (lembra alguma coisa não). Tais problema realmente existiam, como por exemplo, a questão das strings, do tempo de interpretação, o problema do AWT (biblioteca para aplicações desktop), etc.

A questão que várias investimentos e esforços, ao longo do tempo, foram feitos para que a linguagem fosse melhorando e se tornando mais robusta e perfomática. Primeiro foi a adoção completa do bytecode, hotspot, melhoria constantes no algoritmo de garbage collector(coletor de lixo – parte responsável por retirar da memória os objetos que não estão mais em uso), api de threads, melhorias significativas na parte Desktop, e por aí seguem as mudanças. Hoje já estamos na sua sexta versão e em breve virá a sétima. A linguagem que temos atualmente é completamente diferente daquela lançada em 1995 embora ainda guarde muita da filosofia e arquitetura.

Claro que paralelamente as sucessivas melhoras, os próprios computadores e servidores evoluíram muito também. Hoje é normal termos máquinas pessoais com mais de 2Gb de memória e discos rígidos de 500 Mb. Se pensarmos em servidores, a um custo bastante acessível é possível adquirir equipamentos de até 64 Gb de memória, 4 processadores, 64 Bits, etc. Isso logicamente tem um impacto: não tem grande relevância o uso de memória ou cpu por uma linguagem, guardando as devidas proporções, é claro.

Bem fato é que Java é usada amplamente em diversas empresas e representa um parcela significativa do mercado de desenvolvimento. Graças a sua natureza “gratuita”, porém não aberta – mais adiante isso será melhor abordado – uma grande comunidade em seu entorno se formou, facilitando a sua adoção e incrementando a experiência do desenvolvedor com bibliotecas, frameworks, ferramentas, etc.

Porém dado o seu sucesso e sua ampla adoção, parece que Java passou de herói para vilão:  as pessoas mais revolucionárias afirmam que ela é ruim, muito presa, evolui lentamente, extensiva demais, pouco produtiva, etc. Não faltam quadros comparativos de classes Java que fazem algo e outro com código da linguagem B que faz a mesma coisa com bem menos linhas.  Não faltam blogs com artigos dizendo que Java não livre e que é corporativa, que não possui uma sintaxe clara e legível. E por vão outros exemplos.

Duas “linguagens” e suas comunidades se destacam: Ruby e Python. O interessante que ambas, inclusive, surgiram antes do Java.  Seus pontes fortes são sua alta produtividade através de abstrações em alto níveis, sintaxe doce (suggar sintaxe) – um forma de escrever sem grandes amarrações (ponto-virgula, chaves, etc) e extremamente legível -  e natureza dinâmica (podemos alterar o comportamento dos objetos, funções e módulos em tempo de execução de forma ultra simples – meta classes é um exemplo). Outro aspecto relevante é o fato dela serem, realmente open source – software livre : ambas são mantidas e evoluídas pela comunidade não existindo uma entidade, diretamente, responsável por controlá-las.

A primeira questão que fica é : será possível comparar Java a Ruby ou Java a Python ? Dependo do contexto e das métricas.  Podemos dizer que, considerando a sintaxe legíveis e concisas, Java  “perde” pois tem uma escrita mais rígida, formal e menos “humana”. Exemplo

Ruby

10 times do put “Andre Fonseca” end

Java

for (int i = 0, i < 10, i++){

System.out.println(“Andre Fonseca”);

}

Porém essa “fraqueza” do Java lhe confere característica que em outro quesito a torna mais interessante escolha que as demais. Se agora considerarmos, questões como consumo de memória e recursos de máquinas, um código Java ganha com uma boa margem dos demais. Mesmo pensando em Cloud Computing, onde um aumento de demanda pode ser resolvido com acréscimo de máquina, Java parece se mostrar economicamente melhor pois precisa de menos máquina para atender a uma mesmo disponibilidade.

Sendo assim uma conclusão que podemos chegar seria que grande parte das comparações e suas conclusões são inúteis e pouco esclarecedoras. Cada um aborda no contexto que favorece a sua preferida e no final todas são melhores do que as demais, em algum aspecto que seja.

Outra coisa que é extremamente vaga é quando se afirma que “tal coisa não escala” .   O fato de um aplicação ser capaz de aguentar um crescimento de acesso ou uso está muito mais ligada a sua arquitetura do que na tecnologia usada.  Se fosse assim, todas aplicações de massa (sites, portal de jornais, twitter, etc) deveriam ser feitas em assembly pois assim seriam ultra otimizadas.  Um bom exemplo é que vários sites e/ou ferramentas de grande acesso foram feito em Ruby ou Python e funcionam perfeitamente (com alguns problemas que são normais).

A segunda pergunta é se existe uma escolha perfeita e definitiva. Diante a tudo dito até aqui, fica fácil concluir que a resposta coerente seria NÃO . Existe sim, uma escolha coerente com o contexto do desenvolvedor, usuário, recursos, etc.  Qualquer aplicação pode ser feita em Java ou Ruby ou Python, cada uma terá seus pontos fracos e fortes. Cabe ao desenvolvedor colocar tudo isso de forma ponderada e ver quem lhe trará mais lucro frente ao objetivo almejado.

De forma conclusiva e de acordo com os fatos expostos, fica claro que não existe comparação definitiva, nem justa, pois sempre dependerá do contexto e do objetivo desejado. Além disso, Java começou lenta e ruim e foi melhorando com o uso, sugestões da comunidade, entre outras coisas, nada impede que um mesmo esforço ocorra em Ruby e Python e daqui a alguns anos elas estejam tão “corporativas” quanto Java é hoje.

Finalmente minha primeira página com Django

junho 21st, 2009

Meus amigos após horas de tentativa e erro para colocar a primeira aplicação em Django executando, segue abaixo uma rota que irá guia-los melhor. Ao contrário do que eu disse no post anterior, os passos a seguir indicam uma instalação usando o lighttp (ele é mais rápido e leve que o apache).
Bom, em todos os tutoriais que li, eles recomendam uma séria de passo a passo, que a maioria não funciona. Sempre fica faltando o “pulo do gato”. Até parece M$ : )))) .
Vamos ao que interessa:
1 – Baixe e instale os pacotes do lighttp, django, e python-flup para o fastcgi
2 – Após crie seu primeiro projeto Django:

1
 django-admin startproject meu_primeiro_site

3 – dentro do seu novo projeto crie uma aplicação que conterá os dados (controladores, modelos, visões, etc)

1
 django-admin startapp ola

4 – Dentro do diretório de configurações do lighttp, crie um arquivo para o seu site funcionar com customizações.

1
sudo vi /etc/lighttp/conf-availble/10-meu_primeiro_site.conf

5 – o conteúdo do arquivo deve ser algo semelhante a :

server.modules += (“mod_fastcgi”)
server.modules += (“mod_rewrite”)

fastcgi.server = (
“/default.fcgi” => (
“main” => (
“socket” => “/tmp/lighttp-default.sock”,
“check-local” => “disable”,
“bin-path” => “/var/django/projects/primeiro_site/deploy/default.fcgi”
)
)
)

alias.url = (
“/media” => “/var/django/projects/primeiro_site/media”,
“/admin_media” => “/usr/share/python-support/python-django/django/contrib/admin/media/”
)

url.rewrite-once = (
“^(/media/.*)$” => “$1″,
“^(/admin_media/.*)$” => “$1″,
“^(/.*)$” => “/default.fcgi$1″
)

6 – No diretório que você indicou para o bin-path, no meu caso “/var/django/projects/primeiro_site/deploy/default.fcgi”, crie um arquivo chamado default.fcgi com o seguinte conteúdo:

#!/usr/bin/python
import sys, os

sys.path.insert(0, ‘/var/django/projects/primeiro_site/’)
sys.path.insert(0, ‘/var/django/projects/primeiro_site/hello_world/’)

os.chdir(“/var/django/projects/primeiro_site/”)
os.environ['DJANGO_SETTINGS_MODULE'] = “settings”

from django.core.servers.fastcgi import runfastcgi
runfastcgi(["method=threaded", "daemonize=false"])

7 – Transforme este arquivo recem criado em executavel (mude a permissão dele)

1
chmod a+x default.fcgi

8 – Relance o servidor lighttp :

1
sudo /etc/init.d/lighttp restart

9 – Para ver se tudo está ok, vá no diretorio do arquivo default.fcgi e use o python para executá-lo:

1
python ./default.fcgi

Veja os erros e vá corrigindo, pois pode ter problemas de copiar e colar.

Instalando o Django no seu Ubuntu

junho 20th, 2009

Muitas das pessoas que hoje estão aprendendo uma nova linguagem, após passar pelo “feijão com arroz”, quer ver oque pode fazer dentro da nova tecnologia que possa ser aplicável profissionalmente. Uma das coisas que o mercado mais tem demando é desenvolvimento de aplicações web: portais, páginas de informação, páginas de serviços, etc. Assim, acredito, que todas as linguagens tem a seu framework “mágico” que promete ser a mais nova revolução do mercado.
Dentro do Ruby, temos o Rails. Diga de passagem que é um dos poucos casos onde o framework é mais famoso que a linguagem na qual foi feito. O Rails traz uma nova filosofia na forma de desenvolver sistemas web, pois foge do padrão de “toneladas” de xmls de configuração, quilos de código para não fazer nada relacionado com o negócio em si (mais sobre isso veja – busque no google – artigos sobre DDD).
Dentro do Groovy, existe o Grails.[Editado] O Grails é um framework inspirado pelo Rails do Ruby, na linguagem Groovy[/Editado: graças a um comentário]. Ele se utiliza de Springs, Hibernate e tantos outros mais frameworks java para poder fazer oque o Ruby on Rails faz. Não se esqueçam que, como já falei aqui antes em outros post, o Groovy é JAVA, por isso não estranhem o fato dele usar api Java.
Como não poderia ficar de fora da festa, o Python tem também um universo enorme de bibliotecas para fazer a mesma coisas : Construir aplicações web com alta produtividade. Dentro deste cosmo existe um que vem se destacando dos demais devido a sua facilidade, robustez, e amplo uso comercial que tem tido. Ele é o Django.
Com pouco código e passos você consegue construir uma aplicação web de cadastro e listagem. Mas para poder aproveitá-lo é preciso antes de mais nada instalá-lo em sua máquina. Aqui vamos usar o Apache com um mod-python para servidor de páginas. Alguns usos mais profissionais usam um servidor otimizado para a parte estática e o apache para a parte dinâmica (meio doido isso, quando desenvolvia em Java usava o apache para estático e Tomcat, por exemplo, para a parte dinâmica).
Uma outra ressalva para o processo que será apresentado abaixo é que uso um computador com Ubuntu. Possivelmente, para o pessoal que usar Mac ou qualquer outra distribuição Linux, não mude muito (até mesmo nada), mas vale ficar experto.
O primeiro é obter os pacote de instalação do apache, mod-python e biblioteca de conexão do python com mysql.

1
2
sudo apt-get install apache2 libapache2-mod-python
sudo apt-get install mysql-server python-mysqldb

Note que a segunda linha instala o mysql também.
Após instalar o apache e o mod para python e além disso o mysql, para o ubuntu, eu digito a seguinte linha de comando para instalar o django:

1
sudo apt-get install python-django

Isso irá instalar o django e tudo que for necessário para que ele execute. Para testar a sua instalação você pode no seu terminal digitar:

1
django-admin --version

Este comando mostrará a versão do django instalado no seu sistema.
Aguarde os próximos post com explicações de como configurá-lo, montar sua primeira aplicação e etc. Mandem seu feedback.

Um programa Python para tocar mp3

junho 16th, 2009

Pessoal para atender algumas pessoas que acompanham o blog e que me pediram para colocar algumas coisas de Python, vou dar inicio (apesar de ontem já ter postado algo semelhante) a um série de publicações de código em Python para fazer alguma coisa simples ou legalzinha. Assim que estiver aprendendo pode pegar estes trechos de código e usar para entender como funciona alguma coisa e etc.
Espero que gostem.
Abaixo segue um trecho de codigo em Python que vai tocar um mp3 de seu computador. Um dos prerequisitos é que o Tkinter e o tkSnack estejam instalados. Caso não estejam – na hora de executar aparecerá um erro, vai no google que acharam como instalar e de onde baixar (fica como exercício e depois posto aqui como fazer e os endereços).
Vamos ao código

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# -*- coding: utf-8 -*-
from Tkinter import *
import tkSnack
#
root = Tk()
tkSnack.initializeSnack(root)
caminho  = '''D:\DATA\Andre\musica.mp3'''
def toca():
     global caminho
     musica=tkSnack.Sound(load=caminho)
     musica.play()
#
label1 = Label(root,text='Tocando uma musica')
label1.pack(side=TOP)
botao = Button(root,text='Tocar',command=toca)
botao.pack(side=BOTTOM)
root.mainloop()

Divertam-se e postem comentários com variantes e melhorias….. Vamos codificar e pythoniar muito !!!

Criando um relógio em Python

junho 16th, 2009

Para o pessoal que está começando a aprender a programar em python segue abaixo um código de como escrever um relógio. Ele é simples… Ele abre um frame na tela e fica mostrando as horas. A idéia é incrementar o bichinho até ficar interessante, como colocar um alarme que toca uma música, etc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#!/usr/bin/env python
from Tkinter import *
import time
root = Tk()
time1 = ''
aviso = Label(root, font=('verdana', 100, 'bold'), bg='gray',text='Meu relogio')
clock = Label(root, font=('verdana', 100, 'bold'), bg='gray',fg=('white'))
aviso.pack(fill=BOTH)
clock.pack(fill=BOTH, expand=1)
def tick():
    global time1
    # get the current local time from the PC
    time2 = time.strftime('%H:%M:%S')
    # if time string has changed, update it
    if time2 != time1:
        time1 = time2
        clock.config(text=time2)
    clock.after(200, tick)
tick()
root.mainloop( )

Instalando o Python e o Cheetah no Windows

maio 4th, 2009

Esse é daqueles post para me ajudarem a lembrar como fazer um procedimento. Para instalar o python e o Cheetah para trabalhar com templates, é preciso fazer os seguintes passos:
1 – Fazer o download dos arquivos para instalação. No caso do python existe um instalador pronto. No caso do Cheetah existe apenas um arquivo tar.gz
2 – Buscar e baixar o 7zip. É um programinha gratuito para trabalhar com o gz e tar
3 – Instalar o Python
4 – Extrair os arquivos do Cheetah para uma pasta
5 – Colocar na variavel Path o diretorio do python (diretorio onde está o python.exe)
6 – na pasta onde extraiu o Cheetah, onde estiver o arquivo setup.py, executar a linha de comando : python setup.py install ou setup.py install
7 – O procedimento acima vai criar uma pasta Scripts dentro do diretorio do python. dentro desta pasta tem dois arquivos cheetah e cheetah-compile
8 – Copiar os arquivos acima para a pasta c:\Windows … Note que o copy deve ser : copy cheetah c:\Windows\cheetah.py . Tem que colocar a extensão py devido ao fato do windows não entender a primeira linha do arquivo. (so funciona no linux)

Os passos acima devem garantir que funcione.