Páginas

Monday, March 30, 2009

Como falar muito sem dizer nada

Essa semana um professor nos enviou um documento bem humorado dizendo como se comportar em reuniões / apresentações.
Trata-se de uma tabela em que você pode formar frases sintaticamente corretas, porém sem nenhum conteúdo, bastando pegar um trecho de cada coluna.

Coluna 1 Coluna 2 Coluna 3 Coluna 4
Caros colegas, a execução deste projeto nos obriga à análise das nossas opções de desenvolvimento futuro.
Por outro lado, a complexidade dos estudos efetuados cumpre um papel essencial na formulação das nossas metas financeiras e administrativas.
Não podemos esquecer que a atual estrutura de organização auxilia a preparação e a estruturação das atitudes e das atribuições da diretoria.
Do mesmo modo, o novo modelo estrutural aqui preconizado contribui para a correta determinação das novas proposições.
A prática mostra que o desenvolvimento de formas distintas de atuação assume importantes posições na definição das opções básicas para o sucesso do programa.
Nunca é demais insistir que a constante divulgação das informações facilita a definição do nosso sistema de formação de quadros.
A experiência mostra que a consolidação das estruturas prejudica a percepção da importância das condições apropriadas para os negócios.
É fundamental ressaltar que a análise dos diversos resultados oferece uma boa oportunidade de verificação dos índices pretendidos.
O incentivo ao avanço tecnológico, assim como o início do programa de formação de atitudes acarreta um processo de reformulação das formas de ação.
Assim mesmo, a expansão de nossa atividade exige precisão e definição dos conceitos de participação geral.

Então resolvi fazer um rápido script Python para formar frases pra mim, algo como "Quote-of-the-day".

# -*- coding: utf-8 -*-
# phrases.py
from random import choice
from textwrap import dedent

try:
from itertools import product
except ImportError:
# http://docs.python.org/library/itertools.html#itertools.product
def product(*args, **kwds):
# product('ABCD', 'xy') --> Ax Ay Bx By Cx Cy Dx Dy
# product(range(2), repeat=3) --> 000 001 010 011 100 101 110 111
pools = map(tuple, args) * kwds.get('repeat', 1)
result = [[]]
for pool in pools:
result = [x+[y] for x in result for y in pool]
for prod in result:
yield tuple(prod)


_COLUNAS_ = [[u"Caros colegas,",
u"Por outro lado,",
u"Não podemos esquecer que",
u"Do mesmo modo,",
u"A prática mostra que",
u"Nunca é demais insistir que",
u"A experiência mostra que",
u"É fundamental ressaltar que",
u"O incentivo ao avanço tecnológico, assim como",
u"Assim mesmo,"],
[u"a execução deste projeto",
u"a complexidade dos estudos efetuados",
u"a atual estrutura de organização",
u"o novo modelo estrutural aqui preconizado",
u"o desenvolvimento de formas distintas de atuação",
u"a constante divulgação das informações",
u"a consolidação das estruturas",
u"a análise dos diversos resultados",
u"o início do programa de formação de atitudes",
u"a expansão de nossa atividade"],
[u"nos obriga à análise",
u"cumpre um papel essencial na formulação",
u"auxilia a preparação e a estruturação",
u"contribui para a correta determinação",
u"assume importantes posições na definição",
u"facilita a definição",
u"prejudica a percepção da importância",
u"oferece uma boa oportunidade de verificação",
u"acarreta um processo de reformulação",
u"exige precisão e definição"],
[u"das nossas opções de desenvolvimento futuro.",
u"das nossas metas financeiras e administrativas.",
u"das atitudes e das atribuições da diretoria.",
u"das novas proposições.",
u"das opções básicas para o sucesso do programa.",
u"do nosso sistema de formação de quadros.",
u"das condições apropriadas para os negócios.",
u"dos índices pretendidos.",
u"das formas de ação.",
u"dos conceitos de participação geral."]]

frases_vazias = list(product(*_COLUNAS_))
print dedent('''\
De %d frases vazias, escolhi:
"%s"''') % (len(frases_vazias), ' '.join(choice(frases_vazias)))

##for frase in product(*_COLUNAS_):
## print ' '.join(frase)

Monday, March 23, 2009

Web Frameworks

Essa semana eu compilei uma lista de diversos frameworks para desenvolvimento web.
Não me limitei a Python, (quase) todas as linguagens foram consideradas e ainda tentei "separar o joio do trigo" marcando os frameworks mais 'badalados' em cada linguagem.

Eu fiz o original em um mapa mental no MindManager, mas como o formato é proprietário, fica aqui o PNG com o mapa completo exportado.



A lista é a seguinte:

  1. ActionScript
    • Flex
  2. ASP.NET
    • ASP.NET MVC
    • DotNetNuke
    • MonoRail
    • BFC
    • CSLA
    • Umbraco
  3. ColdFusion
    • ColdSpring
    • Fusebox
    • Model-Glue
    • onTap
  4. Groovy
    • Grails
  5. Java
    • Apache Struts 2
    • JavaServer Faces
    • JBoss Seam
    • Spring
    • Stripes
    • Tapestry
    • Apache
      • Click
      • Cocoon
      • Wicket
    • AppFuse
    • Aranea
    • Google Web Toolkit
    • Hamlets
    • ItsNat
    • IT Mill Toolkit
    • OpenLaszlo
    • OpenXava
    • Reasonable Server Faces
    • RIFE
    • Shale
    • SmartClient
    • Sofia
    • ThinWire
    • WebObjects
    • WebWork
    • ztemplates
  6. JavaScript
    • Ajile
    • Axiom Stack
    • WaveMaker
  7. Lua
    • Orbit
    • Kepler
  8. Perl
    • Catalyst
    • Interchange
    • Mason
    • Maypole
  9. PHP
    • CakePHP
    • Prado
    • Symfony
    • Zend
    • CodeIgniter
    • Drupal
    • Akelos
    • eZ Components
    • FUSE
    • Horde
    • Kohana
    • LISA
    • Midgard
    • Nette
    • PEAR
    • Orinoco
    • Qcodo
    • Simplicity
    • SilverStripe (Sapphire)
    • SPIP
    • Tigermouse
    • Zoop
  10. Python
    • Django
    • TurboGears
    • Pylons
    • Zope
    • Grok
    • web2py
    • CherryPy
    • CubicWeb
    • Enamel
    • Gizmo(QP)
    • Glashammer
    • Karrigell
    • notmm
    • Porcupine
    • Pyroxide
    • QP
    • SkunkWeb
    • Spyce
    • web.py
    • Webware
    • Werkzeug
  11. Ruby
    • Ruby on Rails
    • Merb
    • Camping
    • Nitro
  12. Smalltalk
    • Seaside
    • AIDA/Web

Saturday, March 21, 2009

Python tricks: locals(), globals() e keyword arguments (kwargs)

Nessa semana durante uma sessão de pair programming lá na globo.com chegamos a um código que começava a se repetir... um bom momento para melhora, e lá introduzi uma "técnica" muito legal: usar o um dicionário que contém o escopo local para dinamizar o acesso a variáveis/nomes.

Esse dicionário já existe builtin no Python, apesar de eu acreditar que muita gente não saiba ou não o use...
Trata-se do locals() (e seu irmão globals()).

Uso:
def preencher_mensagem(id_mensagem, titulo=None, subtitulo=None, link=None):
id_titulo = MENSAGENS[id_mensagem]['titulo']
id_subtitulo = MENSAGENS[id_mensagem]['subtitulo']
id_link = MENSAGENS[id_mensagem]['link']

if titulo is not None:
preencher_titulo(id_titulo, titulo)

if subtitulo is not None:
preencher_subtitulo(id_subtitulo, subtitulo)

if link is not None:
preencher_link(id_link, link)


Abstraim o resto do código, e pensem nos if's.
Com mais e mais parametros para preencher, isso fica muito repetitivo.
Por que não um loop?
def preencher_mensagem(id_mensagem, titulo=None, subtitulo=None, link=None):
id_titulo = MENSAGENS[id_mensagem]['titulo']
id_subtitulo = MENSAGENS[id_mensagem]['subtitulo']
id_link = MENSAGENS[id_mensagem]['link']

for parte in 'titulo subtitulo link'.split():
texto = locals()[parte]
id = locals()['id_%s' % parte]
preencher = globals()['preencher_%s' % parte]

if texto is not None:
preencher(id, texto)

Notem que com o locals() podemos acessar o dicionário de nomes locais e usar seus valores tanto para leitura quanto para escrita (não recomendada), chamar métodos, etc. O equivalente para o escopo global é o globals().
Ainda poderíamos fazer melhor e usar um dicionário dos parâmetros passados para a função/método, ao invés de 'apelar' para o escopo local.
Basta colocar um argumento que leve ** na frente, e ele será um dicionário de todos os parâmetros passados por nome. Melhor definição, formalismo e mais exemplos na documentação oficial do Python.
def preencher_mensagem(id_mensagem, **partes):
for parte, texto in partes.iteritems():
id = MENSAGENS[id_mensagem][parte]
preencher = globals().get('preencher_%s' % parte)

if preencher is not None:
preencher(id, texto)

Agora, para os que querem rodar alguma coisa que funcione, fiz um script completo que pode ser executado.
Fiz um "banco de dados" fictício só para fins de demonstração.

# -*- coding: utf-8 -*-
# Exemplo usado no meu blog em lifeatmymind.blogspot.com
# Rodolfo Carvalho 2009-03-21

#----- Meu "Banco de Dados" ------------------
MENSAGENS = {1: {'titulo': 4,
'subtitulo': 3,
'link': 1},
2: {'titulo': 1,
'subtitulo': 4,
'link': 2},
3: {'titulo': 2,
'subtitulo': 2,
'link': 4},
4: {'titulo': 3,
'subtitulo': 1,
'link': 3}}

TITULOS = {1: '', 2: '', 3: '', 4: ''}
SUBTITULOS = {1: '', 2: '', 3: '', 4: ''}
LINKS = {1: '', 2: '', 3: '', 4: ''}
#---------------------------------------------

def preencher_titulo(id_titulo, titulo):
TITULOS[id_titulo] = titulo

def preencher_subtitulo(id_subtitulo, subtitulo):
SUBTITULOS[id_subtitulo] = subtitulo

def preencher_link(id_link, link):
LINKS[id_link] = link

#---------------------------------------------

def preencher_mensagem1(id_mensagem, titulo=None, subtitulo=None, link=None):
id_titulo = MENSAGENS[id_mensagem]['titulo']
id_subtitulo = MENSAGENS[id_mensagem]['subtitulo']
id_link = MENSAGENS[id_mensagem]['link']

if titulo is not None:
preencher_titulo(id_titulo, titulo)

if subtitulo is not None:
preencher_subtitulo(id_subtitulo, subtitulo)

if link is not None:
preencher_link(id_link, link)

def preencher_mensagem2(id_mensagem, titulo=None, subtitulo=None, link=None):
id_titulo = MENSAGENS[id_mensagem]['titulo']
id_subtitulo = MENSAGENS[id_mensagem]['subtitulo']
id_link = MENSAGENS[id_mensagem]['link']

for parte in 'titulo subtitulo link'.split():
texto = locals()[parte]
id = locals()['id_%s' % parte]
preencher = globals()['preencher_%s' % parte]

if texto is not None:
preencher(id, texto)

def preencher_mensagem3(id_mensagem, **partes):
for parte, texto in partes.iteritems():
id = MENSAGENS[id_mensagem][parte]
preencher = globals().get('preencher_%s' % parte)

if preencher is not None:
preencher(id, texto)

#---------------------------------------------

def imprimir_mensagens():
def print_linha(conteudo=''):
print '| %s |' % conteudo.center(76)

for id, msg in MENSAGENS.iteritems():
print
print '(%d)' % (id,)
print '-' * 80
print_linha('* %s *' % TITULOS[msg['titulo']])
print_linha('%s' % SUBTITULOS[msg['subtitulo']])
print_linha()
print_linha('%s' % LINKS[msg['link']])
print '-' * 80

if __name__ == '__main__':
preencher_mensagem = preencher_mensagem3

preencher_mensagem(id_mensagem=1,
titulo=u'Olá mundo!',
subtitulo=u'Veja como é divertido usar Python',
link='http://lifeatmymind.blogspot.com')
preencher_mensagem(id_mensagem=2,
titulo=u'Esta é a segunda mensagem cadastrada',
link='http://lifeatmymind.blogspot.com')
preencher_mensagem(id_mensagem=3,
subtitulo=u'Eu não tenho título...',
link='http://lifeatmymind.blogspot.com')
preencher_mensagem(id_mensagem=4,
titulo=u'Última mensagem',
subtitulo='Sou uma mensagem sem link')
imprimir_mensagens()



Um outro exemplo de uso interessante seria:

def tell_story(king, princess, action):
print ('There was a King called %(king)s that had a beautiful daughter. '
'Her name, %(princess)s, would have to be shout in order to make '
'her %(action)s.' % locals())

tell_story("Peter", "Fiona", "ride a horse")
tell_story("Allan", "Britney", "dance")


No trecho acima tem duas coisas interessantes:
  1. Você pode escrever strings grandes sem poluir seu código com linhas super extensas. Siga a recomendação de manter no máximo 80 caracteres por linha. Para escrever strings longas, use-se do artifício da continuação de linha implícita por causa dos parênteses e da concatenação automática de strings postas lado a lado.
>>> "Eu sou uma string" " que continua em outra parte"
'Eu sou uma string que continua em outra parte'

>>> ("Eu sou uma string" " que continua em outra parte"
... " e tambem em outra linha!")
'Eu sou uma string que continua em outra parte e tambem em outra linha!'

  1. Você pode usar o locals() como dicionário para formatação de strings!

O código original é equivalente a:
def tell_story(king, princess, action):
print ('There was a King called %(king)s that had a beautiful daughter. '
'Her name, %(princess)s, would have to be shout in order to make '
'her %(action)s.' % dict(king=king, princess=princess, action=action))

tell_story("Peter", "Fiona", "ride a horse")
tell_story("Allan", "Britney", "dance")

Porém, o original é bem mais sucinto :)

Thursday, March 19, 2009

Provérbio do dia

"O maior dos erros é a pressa antes do tempo, e a lentidão ante a oportunidade"
- Provérbio árabe


Do (excelente) livro "Do Fortran à Internet: no rastro da trilogia Educação, Pesquisa e Desenvolvimento", de Tércio Pacitti.

Saturday, March 14, 2009

Escreva menos, use Python

Ontem vivenciei uma situação em que tivemos que manter um código legado para inserir mais uma pequena funcionalidade.
Uma "regra" aqui é não se desviar do que você tem que fazer (que possui mais valor de negócio) para cuidar de outras coisas. Outra "regra" é não deixar débito técnico.
A grande dificuldade é encontrar o balanço adequado entre esses dois objetivos, e ainda assim implementar sua nova funcionalidade.

Bem, livre de qualquer "regra", vou aproveitar esse post para introduzir 3 recursos do Python que nem sempre são lembrados, e que nos permitem economizar linhas de código, escrevendo de forma clara e concisa o que queremos fazer.

  1. Método get dos dicionários;
  2. Método split das strings;
  3. Função builtin/global setattr.
Vamos partir do seguinte código legado:

#...
from django.shortcuts import render_to_response
from model import Cadastro
#...

def tratar_cadastro(request):
post = request.POST
#...
cadastro = Cadastro()
#...

if post.has_key('nome'):
cadastro.nome = post['nome']

if post.has_key('endereco'):
cadastro.endereco = post['endereco']

if post.has_key('telefone'):
cadastro.telefone = post['telefone']

if post.has_key('email'):
cadastro.email = post['email']

return render_to_response('cadastro/index.html', {"cadastro": cadastro})


É um esboço de uma View do Django. Como podem ver, espera-se que a view seja requisitada via HTTP POST, com a passagem de diversos parâmetros, que ficam armazenados no dicionário Python request.POST. Esse papo de cadastro, nome, telefone, etc é só para ilustrar.
Então o código que temos é uma sequência de if's que setam atributos de uma instância de Cadastro que é posteriormente passada para o template.

Podemos imaginar que temos um formulário numa página que, ao ser submetido, exibe as informações preenchidas para confirmação.

Agora temos que adicionar mais um campo ao cadastro. Digamos que nosso cliente pediu para guardar também o campo "idade". Por simetria, acabaria acontecendo o seguinte:
#...
from django.shortcuts import render_to_response
from model import Cadastro
#...

def tratar_cadastro(request):
post = request.POST
#...
cadastro = Cadastro()
#...

if post.has_key('nome'):
cadastro.nome = post['nome']

if post.has_key('idade'):
cadastro.idade = post['idade']


if post.has_key('endereco'):
cadastro.endereco = post['endereco']

if post.has_key('telefone'):
cadastro.telefone = post['telefone']

if post.has_key('email'):
cadastro.email = post['email']

return render_to_response('cadastro/index.html', {"cadastro": cadastro})


Pra que mudar o que já funciona? Bem, vamos então ao primeiro dos tópicos.
Usar o dict.has_key é ruim e desnecessário. Esse método é deprecated no Python 2.6 e já foi removido da linguagem no Python 3.0, em favor da forma chave in dicionario. No lugar dele e do if deveríamos usar o dict.get.
Mas o que esse método faz? Ele retorna o valor de dict['key'] se o dicionário tem a chave 'key', senão retorna None ou outro valor padrão que o programador especificar.
Ficaria assim:
#...
from django.shortcuts import render_to_response
from model import Cadastro
#...

def tratar_cadastro(request):
post = request.POST
#...
cadastro = Cadastro()
#...

if post.has_key('nome'):
cadastro.nome = post['nome']

cadastro.idade = post.get('idade', u'Campo não preenchido')

if post.has_key('endereco'):
cadastro.endereco = post['endereco']

if post.has_key('telefone'):
cadastro.telefone = post['telefone']

if post.has_key('email'):
cadastro.email = post['email']

return render_to_response('cadastro/index.html', {"cadastro": cadastro})


Além de economizar linhas, temos um código menos redundante e seguindo o princípio de "It's better to beg forgiveness than to ask permission".
Vamos refatorar o resto do código:
#...
from django.shortcuts import render_to_response
from model import Cadastro
#...

def tratar_cadastro(request):
post = request.POST
#...
cadastro = Cadastro()
#...

cadastro.nome = post.get('nome')
cadastro.idade = post.get('idade')
cadastro.endereco = post.get('endereco')
cadastro.telefone = post.get('telefone')
cadastro.email = post.get('email')

return render_to_response('cadastro/index.html', {"cadastro": cadastro})


Assim, caso um dos campos não venha no POST, será atribuído o valor None ao atributo do objeto cadastro.
Notem que, assim como antes, existe bastante duplicação de código (por razões práticas, fiz um exemplo com poucas chaves do dicionário, mas o caso que me deparei eram mais que dez...).
Agora então é a hora de introduzir os outros dois conceitos, o split e o setattr.
O primeiro transforma uma string em lista através de um separador. Exemplo:
>>>  print "um, dois, tres".split(", ")
['um', 'dois', 'tres']

Isso pode ser usado para declararmos uma lista sem precisar de muitas aspas e vírgulas... basta colocar todos os itens da lista em uma string e usar o split.
O outro faz o mesmo que objeto.atributo = valor, porém atributo pode ser algo dinâmico, definido em tempo de execução.
Com essas mudanças, nosso código ganha uma tremenda compressão, sem perder legibilidade:
#...
from django.shortcuts import render_to_response
from model import Cadastro
#...

def tratar_cadastro(request):
post = request.POST
#...
cadastro = Cadastro()
#...

for attr in 'nome idade endereco telefone email'.split():
setattr(cadastro, attr, post.get(attr))


return render_to_response('cadastro/index.html', {"cadastro": cadastro})

Thursday, March 12, 2009

Psicologia Junguiana

Recebi isto hoje por email e acho que parece bastante com minha 'rotina' corrente.
Apesar da ralação, tem sido muito bom. Não me contento com molezinha :P

Exigências da vida moderna (quem agüenta tudo isso??)


Dizem que todos os dias você deve comer uma maçã por causa do ferro.
E uma banana pelo potássio.
E também uma laranja pela vitamina C.

Uma xícara de chá verde sem açúcar para prevenir a diabetes.
Todos os dias deve-se tomar ao menos dois litros de água.
E uriná-los, o que consome o dobro do tempo.
Todos os dias deve-se tomar um Yakult pelos lactobacilos (que ninguém sabe bem o que é, mas que aos bilhões, ajudam a digestão).

Cada dia uma Aspirina, previne infarto.
Uma taça de vinho tinto também.
Uma de vinho branco estabiliza o sistema nervoso...
Um copo de cerveja, para... não lembro bem para o que, mas faz bem.
O benefício adicional é que se você tomar tudo isso ao mesmo tempo e tiver um derrame, nem vai perceber.

Todos os dias deve-se comer fibra.
Muita, muitíssima fibra.
Fibra suficiente para fazer um pulôver.
Você deve fazer entre quatro e seis refeições leves diariamente.
E nunca se esqueça de mastigar pelo menos cem vezes cada garfada.
Só para comer, serão cerca de cinco horas do dia.

E não esqueça de escovar os dentes depois de comer.
Ou seja, você tem que escovar os dentes depois da maçã, da banana, da laranja, das seis refeições e enquanto tiver dentes, passar fio dental, massagear a gengiva, escovar a língua e bochechar com Plax.
Melhor, inclusive, ampliar o banheiro e aproveitar para colocar um equipamento de som, porque entre a água, a fibra e os dentes, você vai passar ali várias horas por dia.

Há que se dormir oito horas por noite e trabalhar outras oito por dia, mais as cinco comendo são vinte e uma.
Sobram três, desde que você não pegue trânsito.

As estatísticas comprovam que assistimos três horas de TV por dia.
Menos você, porque todos os dias você vai caminhar ao menos meia hora (por experiência própria, após quinze minutos dê meia volta e comece a voltar, ou a meia hora vira uma).

E você deve cuidar das amizades, porque são como uma planta: devem ser regadas diariamente, o que me faz pensar em quem vai cuidar delas quando eu estiver viajando.

Deve-se estar bem informado também, lendo dois ou três jornais por dia para comparar as informações.

Ah! E o sexo.
Todos os dias, tomando o cuidado de não se cair na rotina.
Há que ser criativo, inovador para renovar a sedução.
Isso leva tempo e nem estou falando de sexo tântrico.

Também precisa sobrar tempo para varrer, passar, lavar roupa, pratos e espero que você não tenha um bichinho de estimação.

Na minha conta são 29 horas por dia.

A única solução que me ocorre é fazer várias dessas coisas ao mesmo tempo!!!

Tomar banho frio com a boca aberta, assim você toma água e escova os dentes. Chame os amigos e seus pais.
Beba o vinho, coma a maçã e dê a banana na boca da sua mulher.

Ainda bem que somos crescidinhos, senão ainda teria um Danoninho e se sobrarem 5 minutos, uma colherada de leite de magnésio.

Agora tenho que ir.

É o meio do dia, e depois da cerveja, do vinho e da maçã, tenho que ir ao banheiro.

E já que vou, levo um jornal...

Tchau....

Se sobrar um tempinho, me manda um e-mail.

Luís Fernando Veríssimo

Saturday, March 7, 2009

Como abrir o gnome-terminal com múltiplas abas

Para abrir o gnome-terminal com diversas abas, cada uma em um diretório, podemos usar o comando:

gnome-terminal \
--tab --working-directory=/home/user/project1 \
--tab --working-directory=/home/user/another_dir \
--tab --working-directory=/home/user/project1/src/main \
--tab --working-directory=/home/user


Outros dois parâmetros interessantes são " --command='comando a ser executado' " e " --title='titulo da aba' ", porém nenhum dos dois funcionou satisfatoriamente pra mim.

Thursday, March 5, 2009

Mozilla Bespin: web text editor and collaboration tool

Hoje eu conheci o Bespin, graças a meu amigo Flávio Amieiro.

Depois do Coding Dojo Rio de hoje, movimentação na lista e uma possível integração com o pessoal da SEA Tecnologia de Brasília, o Flávio citou o Bespin como ferramenta para fazermos um dojo remoto colaborativo.

Comecei vendo um introdução nesse vídeo:

Introducing Bespin from Dion Almaer on Vimeo.


Basicamente é mais um experimento/projeto em estado alfa de desenvolvimento da equipe do Mozilla Labs. É um editor de código-fonte, atualmente com suporte a sintaxe colorida em Javascript, CSS e HTML.

O Bespin é escrito em Java, Python, e bastante Javascript, HTML e CSS.

Tem suporte experimental a edição colaborativa.

Esta é a interface de "dashboard", com um navegador de arquivos no estilo do Mac OS X.
Na parte de baixo eu dei o comando "help" para receber uma lista dos comandos disponíveis.


Esta é a interface de edição mais a área de colaboração, que no momento parece estar desativada.


Tem um demo do projeto rodando em:
http://bespin.mozilla.com/

Você pode se registrar ou usar um login genérico daqui:
http://www.bugmenot.com/view/bespin.mozilla.com

O código-fonte do Bespin é aberto, e está em um repositório do Mercurial:
http://hg.mozilla.org/labs/bespin/


Vale a pena dar uma olhada neste e outros projetos do Mozilla Labs, a exemplo do Ubiquity e do Prism.

Sunday, March 1, 2009

Brincando com o Bazaar (bzr)

Nesse carnaval tirei um tempo para ver como funciona o Bazaar.

Mas o que é isso? Bem, o Bazaar é um DVCS - Distributed Version Control System -, um software que, simplificadamente, serve para guardar diversas versões de arquivos. Em geral, esses "arquivos" estão relacionados a código-fonte, mas podem ser qualquer coisa, como imagens, pdfs, executáveis, etc.

Um sistema de versionamento famoso é o Subversion (svn), que é um sucessor do CVS. Entretanto, o Bazaar, assim como outros DCVSs, são essencialmente diferentes desses dois.

O SVN e o CVS são sistemas centralizados, com pouco suporte para operações offline, e possibilidades (facilidade) de colaboração limitadas. As operações de controle de versão ocorrem num repositório central, necessitando conexão de rede/Internet.

Já os sistemas distribuídos, possuem diversos repositórios; repositórios locais, onde o desenvolvedor pode salvar (commit) seu trabalho, e repositórios remotos onde ocorre a integração (merge) das partes.

Bem, a minha intenção aqui não é explicar como funciona o SVN nem o CVS, nem dar detalhes do que eles são. O trecho acima foi só para tentar nivelar os desentendidos :)

Mais informações nos links que apontam para a Wikipedia!


Voltando ao Bazaar, existem outros "concorrentes" por aí, boas opções também. Dentre as principais: Mercurial e Git.
Tenho usado o Git no meu estágio, e achei ele um pouco "fora do meu estilo". Também tem um ponto chato que é rodá-lo no Windows -- um grande problema. E como meu dia a dia é Linux pra cá, Windows acolá, então é uma limitação relevante pra mim.

Meu orientador Carlo me deu uma amostra grátis do Bazaar algumas semanas atrás, lá no NCE/UFRJ, e achei por bem tirar um tempo pra brincar com ele por minha conta. E foi o que fiz em algum momento do feriadão de carnaval. Instalei o Bazaar no Ubuntu e passei a usá-lo em um projeto pessoal.

A instalação foi muito fácil. Nos repositórios padrão do Ubuntu 8.10, a versão do Bazaar não era a mais recente, portanto, adicionei ao meu sources.list o repositório do Bazaar no Lauchpad.

Conforme diz aqui bastou eu abrir o gerenciador de pacotes e pedir para adicionar essas duas linhas:

deb http://ppa.launchpad.net/bzr/ppa/ubuntu intrepid main
deb-src http://ppa.launchpad.net/bzr/ppa/ubuntu intrepid main
Depois de atualizar a lista de pacotes disponíveis, lá estava o Bazaar 1.12, assim como o pacote bzr-gtk que traz uma interface gráfica pro mesmo.

Agora enquanto escrevo, vou instalar no Windows...
Extremamente fácil: só baixar e executar. Instalado e funcionando muito bem.
Desta forma, instalei o Bzr standalone, isso é, não está instalado junto ao meu Python do sistema.

Pois é, o Bazaar é escrito em Python, é muito fácil de usar, e é uma mão na roda para por exemplo manter o pendrive, notebook, e outros pcs sincronizados. E de quebra um local faz backup do outro...

A idéia do Bazaar é de ser um software fácil de usar, e com pouco tempo de uso já me sinto confortável para fazer diversas tarefas. Sua documentação é boa, funciona em qualquer lugar que rodar Python, o que significa umm... qualquer lugar...

Também é muito legal usar o bazaar interfaceando com outros sistemas de controle de versão. O Bazaar, até onde sei, é o único que pode ser usado com o SVN, Git, Mercurial, tudo ao mesmo tempo. Existem plugins que integram o bzr com cada um destes outros projetos, de forma que pela linha de comando do bzr posso fazer checkout e commits em repositórios svn... ou git...

Por fim, li uma dica muito bacana sobre como colaborar em projetos usando o bzr. O projeto pode estar usando qualquer controle de versão, ou mesmo usando nenhum :)

A idéia é a seguinte:
    # criar um diretório para guardar seu trabalho
mkdir projeto
cd projeto
# Criar um repositório do bzr (para otimizar o uso de espaço em disco)
bzr init-repo --trees .
# Pegue o codigo oficial do projeto
svn co http://url/do/repositorio/oficial/do/projeto original

Então agora temos um diretório contendo o código original do projeto. A idéia é deixar o diretório "original" intocado, sendo este apenas uma referência.

Agora vamos criar alguns branches no Bazaar para organizar o trabalho:
    # Criando um branch do bzr para o codigo original
cd original
bzr init
bzr add .
bzr ci -m'Importação do projeto'
# Criando um branch principal
cd ../
bzr branch original main

No branch main, podemos fazer as modificações necessárias para fazer o projeto rodar no nosso sistema, se for necessário. Essas modificações não serão enviadas de volta ao repositório original.

    cd main
# Faça as alterações locais e prossiga
bzr ci -m'Adicionando mudanças locais'

Agora, sempre que for trabalhar em um patch/funcionalidade, crie um novo branch para ela. Isso faz com que as mudanças no projeto original sejam independentes.

    # Criando um branch para trabalho em uma funcionalidade
cd ..
bzr branch main algumafuncionalidade
cd
algumafuncionalidade
# Implemente a fucionalidade e então
bzr ci -m'Adicionada funcionalidade xyz'

Agora, certifique-se que o código está atualizado em relação ao original para que seu patch seja limpo (atualize frequentemene para evitar uma grande quantidade de conflitos a serem resolvidos).

    cd ../original
svn update

Isso trará as mudanças do repositório SVN oficial do projeto (pode ser outro comando, de acordo com o controle de versão usado no projeto...). Não deve haver nenhum conflito nesse momento, já que nada foi feito localmente em 'original'. Note que podem haver novos arquivos (linhas com um A na saída do svn update). O comando bzr unknowns pode te ajudar agora. Se houver algum arquivo novo, adicione-o ao bzr:

    bzr add arquivonovo
# ou bzr add $(bzr unknowns)
bzr ci -m'Mesclando com original do svn revisão 1234'

Isso significa que seu branch original está atualizado no bzr. Agora é hora de propagar as novidades para os branches com cada nova funcionalidade. Mas antes vá ao branch main para manter suas alterações de funcionamento local.

    cd ../main
# Mesclar com as alterações em original
bzr merge
# Se houver algum conflito, solucione e então
bzr resolve file
# Quando tudo estiver ok (bzr status e bzr diff podem
# ajudar nessa hora)
bzr ci -m'Mesclando com original do svn revisão 1234'

E agora o mesmo para os branches de cada funcionalidade.

    cd ../algumafuncionalidade
bzr merge
# 'bzr resolve' se necessário
bzr ci -m'
Mesclando com original do svn revisão 1234'

Pode parecer muito trabalho (é mais simples que o Git :P), mas isso é feito bem rápido, especialmente se o desenvolvimento for feito "um passo de cada vez". Entretanto, os benefícios dessa forma de trabalhar superam essa trabalheira.

Como comparado ao svn o bzr é superior na hora de fazer merge, trabalhando desta forma reduzirá a quantidade de trabalho manual necessária para resolver conflitos.

Agora que você tem um nova funcionalidade implementada em um branch, você pode enviá-la para o repositório oficial do projeto!

É muito fácil. Já que separamos as funcionalidades em branches, os diffs sempre serão limpos, e para criá-los:

      bzr diff -r branch:../main > ../funcionalidade.diff

Agora você pode revisar o diff e enviar para os mantenedores do projeto como um patch.

Você pode deixar seu branch de lado, e criar novos branches se quiser trabalhar mais. Se os mantenedores pedirem alguma alteração no seu patch para a funcionalidade que enviou, basta voltar ao branch e fazer as alterações, e enviar um novo diff.

Se o patch for aceito, então suas alterações irão parar na próxima atualização do código no repositório svn, e irão se propagar para todos os seus branches bzr. Não haverá nenhum conflito.

Se o patch não for aceito, mas mesmo assim você qe manter suas alterações localmente, é também fácil. Simplesmente faça um merge do seu branch com o main branch, que então vai propagar para os outros branches de funcionalidade.
    cd ../main
bzr merge ../algumafuncionalidade
bzr ci -m'Adicionando funcionalidade'

Agora, quando você atualizar os outros branches de funcionalidade, eles vão receber a funcionalidade, sem que seus diffs a contenham, mantendo os patches separados.

Se quiser implementar um funcionalidade em várias etapas, você pode criar branches de funcionalidade que dependam um do outro.
     bzr branch main pequena.mudanca
bzr branch
pequena.mudanca grande.mudanca

Agora, as mudanças de pequena.mudanca se propagam para grande.mudanca, e você pode gerar três patches:

   # Diff para implementar pequena.mudanca
cd pequena.mudanca
bzr diff -r branch:../main
# Diff para implementar grande.mudanca
cd grande.mudanca
bzr diff -r branch:../main
# Criar diff para implementar grande.mudancao que é dependente de
# pequena.mudanca. Útil se a segunda parte da mudança ainda precisar
# ser discutida, ou se for aceita em etapas.
cd grande.mudanca
bzr diff -r branch:../pequena.mudanca

Portanto, fica aqui uma amostra de como o bzr pode trazer flexibilidade para trabalhar em um projeto, não importa qual controle de versão que seja usado oficialmente.


E eu, super feliz com o bzr :)

Anexos no Gmail: seleção múltipla e barra de progresso!

Eis que o Gmail ganhou mais uma novidade, muito esperada por mim :)
Só fui reparar agora, mas parece que essa novidade já está funcionando desde dia 25... (não notei nada diferente nos emails que enviei com anexo até o último que enviei agora a pouco...)

Agora, ao invés de ter que selecionar anexos um a um quando queremos compartilhar vários arquivos, podemos selecionar todos de uma só vez.
Isso funciona assim em outros lugares como Wordpress e Slideshare, e é extremamente conveniente. Também traz a sensação / experiência de usuário de uma aplicação desktop, onde isso é mais comum.

O fato é que agora na hora de enviar fotos não preciso apelar pro Thunderbird ou outro cliente de email... fica mais fácil passar mais tempo só na interface web!


Além dessa facilidade, a equipe do Gmail colocou uma barra de progresso, que ajuda a estimar quanto tempo vai levar para terminar de carregar seu anexo. Também muito útil quando anexando arquivos grandes e/ou em uma conexão com a Internet instável.

Mais detalhes no blog oficial:

Official Gmail Blog: Updates to attachments: multi-select and progress bars