27 de outubro de 2009

Crônicas de um Linuxista

(When I wrote I had forgotten I decided to post in english...)

A cada seis meses ouço a mesma história de mim mesmo. Sabendo que o Ubuntu costuma ser lançado nos últimos dias dos mês de Abril e Outubro, me comprometo a deixar a ansiedade de lado e só verificar se chegou a nova versão no mês seguinte ao do seu lançamento (juro, eu sempre faço isso). Mas no final das contas eu acabo contando os dias para baixá-lo. E neste semestre não foi diferente, estou esperando correr mais dois dias para eu finalmente colocar as mãos na versão 9.10.

16 de julho de 2009

Technologies And Decisions

I'll start to post in english (or try to), right now.

When I started my project I had to make decisions, import ones.

First, a programming language. And behind me there were Delphi (terrible), Python and Ruby.

I came to know about Python on Kurumin (Linux distro), I just had installed. So I read about it and I was wondering why Kurumin came within Python, and eventually I figured out that Linux community was walking toward Python. After many days of researching I finally chose Python, mainly for three reasons:
* its patent simplicity
* its indented block audacious feature
* its connection to Linux
* its promising future

Second step, I needed to choose beetween Windows and Linux. Well, this was easy, most developers dont want to become a hostage of Microsoft softs. I just had to choose a distro now. At Brazil at that time, everyone recommended Kurumin. And it was really beautiful. Good graphs etc. But fortunelly, I was looking forward, and unfortunelly Kurumin was entirely portuguese-oriented, wich I thought was a problem. Then, looking and reading, looking and reading, I was sure that Ubuntu was a very good option. Great! It became solid and very popular. Ubuntu's last release (9.04) is the most complete and stable Linux distro I've ever seen (and the most unstable was 7.09 -- for me).

As I chose Ubuntu, I picked up glade-pygtk as GUI.

And for database, unfortunelly I chose MySQL. It looked so enthusiasmatic at that time, but they started to become more and more closed, and it end up with Sun's acquistion.

Today, we're studying on how to migrate to Postgre.

13 de abril de 2009

Arte da Humildade & Crítica


(...) Num congresso de estudantes colocaram-me para falar em penúltimo lugar, e o encerramento foi feito por um profissional do deboche. Ele simplesmente destruiu o meu discurso otimista anterior, dizendo que o Brasil jamais daria certo, de que estávamos condenados pelo gene do patrimonialismo português, que o fracasso estava no nosso sangue, e assim por diante. Para a minha grande surpresa, a platéia simplesmente adorou. Riam a valer, e no final aplaudiram de pé. Inacreditável para mim!

Se um grande intelectual prevê que o Brasil jamais dará certo, não precisamos nos esforçar. Pode-se justificar o nosso fracasso pessoal, nossa mediocridade individual, como sendo inevitável, é nosso destino. “Não preciso melhorar, a culpa não é minha, a culpa é do Brasil, a culpa é dos portugueses”.

Muitos de nossos intelectuais jogam para a platéia, curvando-se à força do mercado, um discurso de que jamais daremos certo, quando a função do intelectual seria justamente mostrar as soluções, mostrar o caminho, mostrar o que nós pobres mortais não vemos.

(...)

O jornalismo do deboche é um fenômeno mundial, atingiu até o New York Times. Se acabou acreditando que você é mais competente que Lula, FHC ou Bush, consulte um especialista.

O mundo não é tão simples nem tão ridículo quando lhe fizeram imaginar. Graças a Deus!

-- Stephen Kanitz em O Jornalismo do Deboche.

6 de abril de 2009

O Curioso Caso da B. Próclise

Esqueça tudo o que você tem lido sobre colocação pronominal e faça, por favor, o teste abaixo:

Assinale em cada série a alternativa que corresponde ao seu modo de falar mais natural e espontâneo:

1.a) Você pode me emprestar uma caneta?
b) Você pode emprestar-me uma caneta?
c) Você me pode emprestar uma caneta?

2.a) O trabalho tem me ocupado demais ultimamente.
b) O trabalho me tem ocupado demais ultimamente.

3.a) Me disseram que você parou de fumar, é verdade?
b) Disseram-me que você parou de fumar, é verdade?

4.a) Me ajuda aqui!
b) Ajuda-me aqui!

5.a) A festa se realizará no saguão da igreja.
b) A festa realizar-se-á no saguão da igreja.


Se você assinalou, em todos os casos, as alternativas com letra (a), parabéns: você é um(a) legítimo(a) falante do português brasileiro contemporâneo! E como todos os falantes do português brasileiro contemporâneo, você sabe, intuitivamente, que só existe uma única regra de colocação pronominal na nossa língua: a próclise ao verbo principal, isto é, o pronome colocado antes do verbo principal. Pronto, gente, acabou! Tá tudo resolvido! Vamos agora cuidar do que interessa, tentar pagar as contas do mês e levar a nossa vida em paz?

-- Retirado do artigo de Margos Bagno na revista Caros Amigos de Janeiro/2009

26 de março de 2009

Snoopy & Cia

(Clique na imagem para ver a tira inteira)

Tradução livre:
-- Outra bola, jogo perdido!! Ótima chatisse!
-- Estou cansado de perder... Tudo que eu faço, eu perco!
-- Olhe dessa forma, Charlie Brown... Nós aprendemos mais na derrota que o fazemos quando ganhamos.
-- ISSO ME FAZ A PESSOA MAIS ESPERTA NO MUNDO!!

23 de março de 2009

Portabilidade do PyGTK

Na última semana consegui com sucesso fazer a migração de dois terminais de Windows para Ubuntu.

Me impressinou a facilidade com que se deu. GTK se mostrou realmente cross-platform. A adaptação da engine em Python foi quase zero, e no que tange à PyGTK não foi preciso mudar nenhum "til" sequer. Tudo rodou com perfeição. Alguns outros dispositivos precisarão apenas de re-enquadramento da interface desenhada em Glade, isso porque Ubuntu usa um tamanho de letra maior por padrão.

Sem falar, é claro, da facilidade com que se pode configurar a rede em Ubuntu, já que ele reconhece a rede Windows automagicamente. Uma vez que usamos MySQL tudo ficou muito fácil. Por alguma razão ainda desconhecida o terminal com Ubuntu não acessa MySQL por meio do nome da máquina, mas somente pelo IP. De modo que foi necessário colocar um IP fixo para o servidor e para os terminais com Ubuntu.

Nos próximos dias todo o sistema vai estar nos trilhos de Ubuntu. Thanks God.

Numa segunda etapa, parte do que está em PyGTK vai para Django (não tudo).

16 de março de 2009

New Life

Tem umas coisas mucho locas acontecendo. Pretendo passar a relatar em breve. Por hora, o que posso dizer que é sempre melhor buscar a Deus que satisfazer as concupisciências da carne. Não, não falo com quem está acima do bem e do mal, mas como quem humildemente também precisa de correção.

5 de março de 2009

Além da Janela de Casa


De noite assistindo tv, vi um personagem tocar no piano um blues ou algo assim. Procurei na internet alguns vídeos de Boogie Woogie. Ouvi algumas canções. Lembrei de alguns antigos sonhos. Afinei e dedilhei um velho violão. De volta estava em paz, me dei conta: do outro lado da janela tem vida, longe das gazetas, da conta bancária, dos jogos políticos, da programação sem fim.

4 de março de 2009

Linux.com agora é do "Linux"

Notícia da hora! A Linux Foundation comprou o domínio Linux.com (notícia aqui).

De acordo com a Wikipedia:

Linux Foundation foi criado dia 21 de janeiro de 2007 [1] juntando Open Source Development Labs (OSDL) e Free Standards Group. A Fundação vai ajudar a desenvolver o Linux. Linux Foundation vai proteger e padronizar o Linux. Vai ajudar com meios e serviços aos projetos para poder concorrer com outras sistemas operacionais. Linux Foundation tem mais que 70 membros como: AMD, Cisco, EMC, Fujitsu, HP, Hitachi, IBM, Intel, Motorola, NEC, Nokia, NetApp, Novell, NTT, Oracle, Siemens, Unisys e Sun Microsystems.

Linux Foundation emprega o próprio Linus Torvalds[2], ajuda na collaboração entre as empresas de Linux e na proteção da marca Linux.

3 de março de 2009

Por que Python?

Primeiro, se o programador precisa trabalhar próximo ou junto ao Hardware, use logo C, C++ ou outra de médio ou baixo nível. Nos demais casos, PyCappuccino recomenda Python, seja web, desktop ou qualquer outra engine*. É bom dizer que Python é extensível para C.

Fique claro também que nunca se inventou e provalvemente nunca será inventada uma linguagem de programação perfeita, ainda menos uma que se destine a todos os casos.

Vamos lá.

# Porque em Python a delimitação de bloco se dá por indentação

Essa foi uma das coisas que primeiro me entusiasmou na primeira vez que tive contato com Python. Veja um exemplo simples.
def par_ou_impar(inteiro):
 x = inteiro / 2.
 y = int(x)
 if x == y:
     return "par"
 return "impar"

par_ou_impar(7)
# Retorna "impar"
Pensemos. Se por boa técnica de programação se usa indentação, por que não usar a indentação de uma vez para delimitar um bloco. Pois em Python você não precisa se preocupar em fechar ifs, fors, whiles, funções, classes. Uma vez que você assume que abriu um bloco, intuitivamente você indenta, e saindo daquele nível de indentação, o bloco se fecha.

No exemplo se vê que a função "par_ou_impar" não possui um "fechador" porque seu bloco está dentro do primeiro nível indentado, e uma vez que se desce o nível de indentação o bloco já é fechado. Nesse em particular, o comando "return" ao ser executado irá também fechar a função, mas mesmo que não houvesse "return" o bloco seria fechado quando o interpretador encontrasse a primeira linha com recuo da indentação.

Na mesma esteira o "if" abre um bloco e não precisa de fechador já que é fechado pela indentação da linha seguinte (um nível abaixo). Como "return" fecha a função não precisamos colocar um "else".

Além da facilidade que a indentação fixa proporciona a quem programa, também facilita em muito a leitura de um código, o raciocínio fica coerente, visto que tudo está necessariamente indentado. Outra vantagem é que uniformiza todo os códigos.

Aguarde em breve, outros artigos desta série.

* Há os que objetam que Lua é uma excelente linguagem-cola.

6 de fevereiro de 2009

Freetime: a Time OO Module

As datetime.time and time (module) didn't solve my problem, I wrote this one for time calculation free of date. Here are some examples of use:


>>> from freetime import Time
>>> # Let's begin calling the static method 'now'
>>> now = Time.now()
>>> now
freetime.Time(hours=9, minutes=21, seconds=52, microseconds=609000)
>>> now.minutes
21
>>> # calc 1034 minutes from now
>>> after = now + Time(minutes=1034)
>>> after
freetime.Time(hours=26, minutes=35, seconds=52, microseconds=609000)
>>> # Let's know how it represents in seconds
>>> after_in_seconds = Time(None, None, microseconds=None) + after
>>> after_in_seconds
freetime.Time(hours=None, minutes=None, seconds=95752.01015, microseconds=None)
>>> after_in_seconds.seconds
95752.010150000002
>>> # But they are equal, aren't they?
>>> after == after_in_seconds
True
>>> # Let's rollback to full time
>>> full = after_in_seconds.to_full_time()
>>> full
freetime.Time(hours=26, minutes=35, seconds=52, microseconds=609000.0)
>>> # Sum 'now' and 'after_in_seconds'
>>> added = now + after_in_seconds
>>> added
freetime.Time(hours=35, minutes=57, seconds=44, microseconds=1218000.0)
>>> # If in your case time can only have 24 hours
>>> added.to_24_hours()
freetime.Time(hours=11, minutes=57, seconds=44, microseconds=1218000.0)
>>> # To know how many days and hours it would be
>>> days, obj = added.calc_days()
>>> days
1
>>> obj
freetime.Time(hours=11, minutes=57, seconds=44, microseconds=1218000.0)

___________________________

AND HERE IS THE CODE:


"""
OO Time module for calculation free of date.
>>> from freetime import Time
>>> # Let's begin calling the static method 'now'
>>> now = Time.now()
>>> now
freetime.Time(hours=9, minutes=21, seconds=52, microseconds=609000)
>>> now.minutes
21
>>> # calc 1034 minutes from now
>>> after = now + Time(minutes=1034)
>>> after
freetime.Time(hours=26, minutes=35, seconds=52, microseconds=609000)
>>> # Let's know how it represents in seconds
>>> after_in_seconds = Time(None, None, microseconds=None) + after
>>> after_in_seconds
freetime.Time(hours=None, minutes=None, seconds=95752.01015, microseconds=None)
>>> after_in_seconds.seconds
95752.010150000002
>>> # But they are equal, aren't they?
>>> after == after_in_seconds
True
>>> # Let's rollback to full time
>>> full = after_in_seconds.to_full_time()
>>> full
freetime.Time(hours=26, minutes=35, seconds=52, microseconds=609000.0)
>>> # Sum 'now' and 'after_in_seconds'
>>> added = now + after_in_seconds
>>> added
freetime.Time(hours=35, minutes=57, seconds=44, microseconds=1218000.0)
>>> # If in your case time can only have 24 hours
>>> added.to_24_hours()
freetime.Time(hours=11, minutes=57, seconds=44, microseconds=1218000.0)
>>> # To know how many days and hours it would be
>>> days, obj = added.calc_days()
>>> days
1
>>> obj
freetime.Time(hours=11, minutes=57, seconds=44, microseconds=1218000.0)
"""

from __future__ import division

__author__ = "Eduardo Willians Oliveira Bandeira de Melo "
__file__ = "freetime.py"
__license__ = ("LGPL", 3.0)

import datetime

class Time(object):

def __init__(self, hours=0, minutes=0, seconds=0,
microseconds=0):
self.hours = hours
self.minutes = minutes
self.seconds = seconds
self.microseconds = microseconds

@staticmethod
def now():
t = datetime.datetime.now().time()
return Time(t.hour, t.minute, t.second, t.microsecond)

def __str__(self):
return ("freetime.Time(hours=%s, minutes=%s, seconds=%s, "
"microseconds=%s)" % (
self.hours, self.minutes, self.seconds, self.microseconds))

def __repr__(self):
return self.__str__()

def __add__(self, other):
x, y = self._shared_op(other)
return self._to_time(x+y)

def __sub__(self, other):
x, y = self._shared_op(other)
return self._to_time(x-y)

def __div__(self, other):
x, y = self._shared_op(other)
return self._to_time(x/y)

def __truediv__(self, other):
x, y = self._shared_op(other)
return self._to_time(x/y)

def __mul__(self, other):
x, y = self._shared_op(other)
return self._to_time(x*y)

def __eq__(self, other):
x, y = self._shared_op(other)
return (x == y)

def __ne__(self, other):
eq = self.__eq__(other)
return False if eq else True

def __lt__(self, other):
x, y = self._shared_op(other)
return x < y =" self._shared_op(other)" y =" self._shared_op(other)"> y

def __ge__(self, other):
x, y = self._shared_op(other)
return x >= y

def _shared_op(self, other):
if other.__class__ != self.__class__:
raise TypeError
self_ms = self._to_microseconds(self)
other_ms = self._to_microseconds(other)
return (self_ms, other_ms)

def _to_microseconds(self, obj):
ms = obj.microseconds or 0
ms += ((obj.hours or 0) * 60 * 60 * 60000000)
ms += ((obj.minutes or 0) * 60 * 60000000)
ms += ((obj.seconds or 0) * 60000000)
return ms

def _to_time(self, microseconds):
h = 0
m = 0
s = 0
ms = microseconds
if self.microseconds is None:
s += (ms/60000000)
ms = None
elif None not in (self.seconds, self.minutes, self.hours):
while ms >= 60000000:
s += 1
ms -= 60000000
if self.seconds is None:
m += s/60
s = None
elif None not in (self.minutes, self.hours):
while s >= 60:
m += 1
s -= 60
if self.minutes is None:
h += m/60
m = None
elif self.hours is not None:
while m >= 60:
h += 1
m -= 60
if self.hours is None:
h = None
return self.__class__(h, m, s, ms)

def to_full_time(self):
"@return: a new object"
obj = self.__class__()
return obj + self

def to_24_hours(self):
"@return: a new object"
obj = self.to_full_time()
h = obj.hours
while h >= 24:
h -= 24
return self.__class__(h, obj.minutes, obj.seconds, obj.microseconds)

def calc_days(self):
"@return: tuple(days, freetime.Time obj)"
obj = self.to_full_time()
h = obj.hours
days = 0
while h >= 24:
days += 1
h -= 24
new = self.__class__(h, obj.minutes, obj.seconds, obj.microseconds)
return (days, new)

29 de janeiro de 2009

Personal Python 3

E se Python 3 fosse meu:
  • Não haveria 'self' obrigatório como primeiro argumento na definição de um método:
    def method(arg1, arg2):
    self.attr = True
  • 'self' seria um keyword e apareceria magicamente no escopo do método.
    -- Como seria implementado isso?? Não faço a mínima idéia (portanto não poderia fornecer essa resposta ao Guido. Pelo que se dá pra inferir, se houvesse uma maneira simples de fazê-lo, Rossum já o teria feito).
  • str( ), len( ), int( ), float( ), max( ) e min( ) seriam métodos (favor não me argumentar que str( ) invoca o método __str__( ), dentre outros semelhantes, porque estou levando isso em consideração).
  • join( ) seria um método de 'list'
  • Toda a biblioteca padrão teria as funções e métodos com nomes seguindo o modelo 'nome_nome' e nada de 'nomeNome' ou 'nomenome'.
No resto, acho que tudo está excelente em Python 3.

16 de janeiro de 2009

Eric

No princípio eu usava a boa e velha IDLE, e usei por bastante tempo. Depois tentei usar Wingware, mas não me adaptei. Em seguida o Komodo Editor, esse sim gostei e usei um bom tempo. Por fim lembrei que existia um tal Eric. Dei-lhe uma chance. Batata. Muito bom, uma ótima IDE, adotei-o.

E agora o Eric tem versão para Windows. Ainda mais porque ele é fácil de instalar -- sem ter que procurar por gambiarras em fóruns pelo Google.

Atualização [resposta ao comentário de Ale]
Para achar Wingware, Komodo ou Eric basta digitar esses nomes no Google ao lado da palavra "Python". Para instalar Eric em Windows é preciso instalar a biblioteca PyQt. Para instalar o Komodo no Ubuntu só fazendo gambi complicada da pega. Se tiver alguma dificuldade é só deixar um comentário aqui.

13 de janeiro de 2009

1,95 Trilhão de Dólares de Reserva na China

Dá para acreditar? Leia a notícia >>

Se concebermos que a economia é um fenômeno social e portanto subjetivo, sempre é possível criar ilusões tangíveis e duráveis. Os EUA imprimiram trilhares de dólares conseguindo evitar hiperinflação baseados na premissa segundo a qual se o dinheiro impresso é enviado para fora não causará inflação dentro dos EUA, logo o pagamento de juros aos credores estrangeiros pode ser feita simplesmente fabricando dinheiro. Mas até quando isso vai funcionar? Até quando as pesssoas acreditarem. E se um dia falhar? Crise sistêmica.

10 de janeiro de 2009

Django & Storm

Eita que a coisa está melhorando. A API de integração de Storm com Django foi incluída no pacote do último release de Storm 0.14 que saiu ontem. De acordo com Henstridge:

(...) So it is desirable to have the two ORMs sharing a single connection. The way I’ve implemented this is as a Django database engine backend that uses the connection for a particular named per-thread store and passes transaction commit or rollback requests through to the global transaction manager. Configuration is as simple as:
DATABASE_ENGINE = 'storm.django.backend'
DATABASE_NAME = 'store-name'
STORM_STORES = {'store-name': 'database-uri'}

This will work for PostgreSQL or MySQL connections: Django requires some additional set up for SQLite connections that Storm doesn’t do.

Once this is configured, things mostly just work. As Django and Storm both maintain caches of data retrieved from the database though, accessing the same table with both ORMs could give unpredictable results. My code doesn’t attempt to solve this problem so it is probably best to access tables with only one ORM or the other.

8 de janeiro de 2009

Crônicas De Um Programador

Decidira colocar em prática a escolha pessoal de publicar o fonte das minhas bibliotecas, mesmo que eu não seja um expert.

Mas antes resolvo dar uma olhada para ver se o código estaria mais ou menos tragável. Eis então que ressoa minha consciência:
  • Hmm.. tenho que terminar de por tudo em inglês
  • Que mistureba é essa que eu fiz?
  • Nossa! Se eu puser isso na net vão rir de mim
  • Documentação, documentação...
  • Esse pedaço antigo não dá para apagar ainda
  • Será que vão entender isso aqui...

Resultado: Ainda não tive coragem de publicar.