Planeta PythonBrasil

Backwards and forwards compatibility is an art. In the very basic and generic form, it consists in organizing the introduction of new concepts while allowing people to maintain existing assets working. In some cases, the new concepts introduced are disruptive, in the sense that they prevent the original form of the asset to be preserved completely, and then some careful consideration has to be done for creating a migration path which is technically viable, and which at the same time helps people keeping the process in mind. A great example of what not to do when introducing such disruptive changes has happened in Python recently.

Up to Python 2.5, any strings you put within normal quotes (without a leading character marker in front of it) would be considered to be of the type str, which originally was used for both binary data and textual data, but in modern times it was seen as the type to be used for binary data only. For textual information, the unicode type has been introduced in Python 2.0, and it provides easy access to all the goodness of Unicode. Besides converting to and from str, it’s also possible to use Unicode literals in the code by preceding the quotes with a leading u character.

This evolution has happened quite cleanly, but it introduced one problem: these two types were both seen as the main way to input textual data in one point in time, and the language syntax clearly makes it very easy to use either type interchangeably. Sounds good in theory, but the types are not interchangeable, and what is worse: in many cases the problem is only seen at runtime when incompatible data passes through the code. This is what gives form to the interminable UnicodeDecodeError problem you may have heard about. So what can be done about this? Enter Python 3.0.

In Python 3.0 an attempt is being made to sanitize this, by promoting the unicode type to a more prominent position, removing the original str type, and introducing a similar but incompatible bytes type which is more clearly oriented towards binary data.

So far so good. The motivation is good, the target goal is a good one too. As usual, the details may complicate things a bit. Before we go into what was actually done, let’s look at an ideal scenario for such an incompatible change.

As mentioned above, when introducing disruptive changes like this, we want a good migration path, and we want to help people keeping the procedure in mind, so that they do the right thing even though they’re not spending too many brain cycles on it. Here is a suggested schema of what might have happened to achieve the above goal: in Python 2.6, introduce the bytes type, with exactly the same semantics of what will be seen in Python 3.0. During 2.6, encourage people to migrate str references in their code to either the previously existent unicode type, when dealing with textual data, or to the new bytes type, when handling binary data. When 3.0 comes along, simply kill the old str types, and we’re done. People can easily write code in 2.6 which supports 3.0, and if they see a reference to str they know something must be done. No big deal, and apparently quite straightforward.

Now, let’s see how to do it in a bad way.

Python 2.6 introduces the bytes type, but it’s not actually a new type. It’s simply an alias to the existing str type. This means that if you write code to support bytes in 2.6, you are actually not writing code which is compatible with Python 3.0. Why on earth would someone introduce an alias on 2.6 which will generate incompatible code with 3.0 is beyond me. It must be some kind of anti-migration pattern. Then, Python 3.0 renames unicode to str, and kills the old str. So, the result is quite bad: Python 3.0 has both str and bytes, and they both mean something else than they did on 2.6, which is the first version which supposedly should help migration, and not a single one of the three types from 2.6 got their names and semantics preserved in 3.0. In fact, just unicode exists at all, and it has a different name.

There you go. I’ve heard people learn better from counter-examples. Here we have a good one to keep in mind and avoid repeating.

class X {
    public:
        X(int);
        ~X();

        int get(void) const;

    private:
        int value;
}

class X {
    class Ximpl;

    public:
        X(int);
        ~X();

        int get(void) const;

    private:
        Ximpl *pimpl;
}

class X::Ximpl {
    public:
        Ximpl(int);
        ~Ximpl();

        int get(void) const;

    private:
        int value;

}

X::X(int value): pimpl(new X::Ximpl(value)) {
    // Nada mais a fazer
}

X::Ximpl::Ximpl(int value): value(value) {
    // Nada mais a fazer
}

X::~X() {
    delete this->pimpl;
}

X::Ximpl::~Ximpl() {
    // Nada mais a fazer
}

X::get(void) const {
    return this->pimpl->get();
}

X::Ximpl::get(void) const {
    return this->value;
}

Yes, you’ve heard it right. I’ll exchange a legally unlocked iPhone 3G for a recent Android phone such as the Samsung Galaxy or the HTC Hero, and will pay the difference back! (street price minus 30% of devaluation for the used iPhone 3G).

I got an iPhone some time ago to learn the concepts introduced in the platform, and get a feeling of how it works out in practice. I’m happy I did it, since the hands on experience is worthwhile. But the experience is done, and even though I have positive things to say about the platform, the omnipotent and arrogant position of Apple with developers kills any chance of any further involvement I could have with the platform. I’m upset enough with it that I don’t want to see my wife using the device either.

There are many things in Apple’s behavior which are a source of arguments, and interminable flamewars, and most of the times I can see both sides of the story. For instance, when people pay a premium to get the hardware, some feel like it’s just throwing money away, but if there is good engineering behind it, well.. I understand people may want to pay the premium to get that exclusive product they like. That said, being so incredibly arrogant in the marketplace, and with developers, which theoretically should be their most precious partners, since they sustain the platform going, is something I can’t tolerate.

I know.. who am I. Just a random guy that actually gave them some money for one of their products. But I’m also a guy that won’t be buying their upgraded phones, and will be spreading the word to make people realize what a terrible future it will be if Apple ever dominates the marketplace. Even you’re not a developer, it’s a good idea to ponder carefully about this behavior. It tells a lot about how far they go to defend their own interests, and what kind of lock in they intend to get you into.

Finally, compare that to a nice open source operating system on which multiple first class vendors are cooperating. Sheeshh.. easy choice for me.

void myFunction(Object... args) {
    // Código do método
    …
}

Funções variárias em C/C++

#include <cstdio>
#include <cstdarg>

#include <stdio.h>
#include <stdarg.h>

void printargs(int arg1, ...) {

    va_list args;

    va_start(args, arg1);

    printf("%d", arg1);

char c = static_cast<char>(va_arg(va, int));

    int arg;
    while((arg = va_arg(args, int)) >= 0)
        printf(" %d", arg);

    va_end(arg);
    printf("\n");
}

extern void
log(int level, cons char *fmt, ...)
__attribute__((format(printf, 2, 3)));

Are you? I’m not entirely sure I am, even though I think about this a lot.

If you’re of the tech-savvy kind, you’re certainly aware of the great capabilities that the new mobile phone generation is bringing: Internet connection, a quite decent browser, GPS, camera, etc. But, really.. did you stop to think about what’s going on? This phone generation is still relatively expensive today, but they’re here to stay, and in just a few years, they’ll be commonplace.

Now, let’s forget about ourselves for a moment, and think about what mass adoption of a quite capable generic computer with full internet connectivity 24h a day being carried with its owner means for the world? Remember, the number of mobile phone users in the world is several times superior to the number of computers, and most of the computers are in the so called first world.

This implies that not only will everyone have access to the world in their pockets, which is already quite amazing by itself, but that a large number of people will have access to the Internet at all for the first time with their mobiles. Besides the several social impacts that these changes will bring, there are also many other interesting consequences. As simple examples, the most common client to many web services will be mobile phones, and many people will learn to use a touch screen interface of the mobile to interact with the world before ever having used a desktop computer for that.

I find that amazing, and this is happening right now, in front of our eyes.

Oi pessoal, desta vez eu vou pular as ‘desculpas’ por ter demorado tanto para postar aqui no blog e vamos direto ao assunto.

Recentemente eu tenho trabalhado bastante com Python (dã!) desenvolvendo projetos de diversos tipos e resolvi escrever aqui sobre algumas coisas que pratico enquanto desenvolvo.

Código mais robusto

Deu certo ou errado?

O que você faz quando acontece algo errado na execução do seu método? O que você responde à requisição que lhe foi feita?

Eu tenho visto em muito código por aí os desenvolvedores retornando valores sentinela (None, null, 0, -1, etc.) para avisar que algo incorreto aconteceu na execução do método.

def f(arg):
   if not arg:
      return None
   return [ "resultado", "de", "um", "processamento"  ]

Algumas linguagens de programação não possuem estruturas de tratamento de exceção e, neste caso, o uso de sentinelas é válido. Mas quando a linguagem de programação te disponibiliza essa funcionalidade é bom usá-la.

def f(arg):
   if not arg:
      raise ValueError("Argumento Invalido")
   return [ "resultado", "de", "um", "processamento"  ]

Deixem as exceções fluirem.

Isso mesmo. A menos que você saiba exatamente o que você deve fazer quando uma exceção aparece deixe-a exceção “subir”. Pode ser que “lá em cima” alguém saiba cuidar dela adequadamente.

Quando não fazemos isso estamos ocultando informação importante para os usuários do nosso código (sejam eles usuários, outros desenvolvedores ou nós mesmos).

def f():
   try:
      return conecta()
   except ExcecaoQueDeveriaSerErro:
      return None

Quando eu implemento esse tipo de método/função eu faço assim (na verdade eu não implementaria f() e chamaria conecta()):

def f():
   return conecta()

O que seu método/função retorna?

Código que eu encontrei recentemente:

def get_fulanos():
   q = Q("select * from patuleia where alcunha like 'fulano%'")
   ret = [ str(fulano['nome']) for fulano in q ]
   if len(ret) == 1:
      return ret[0]
   return ret

Perceberam o que está errado? O seu método retorna uma lista de Fulanos ou retorna Fulano?

Isso está conceitualmente errado e pode fazer você perder horas preciosas do seu dia tentando achar um bug causado por esse tipo de código.

Aconteceu comigo. Note que str() implementa uma interface de sequence da mesma forma que list(). Então o erro passa silenciosamente no caso abaixo:

old_fulanos = [ "Ze Ruela", "Ze Mane" ]
old_fulanos.extend(get_fulanos())
print old_fulanos

Rodando esse código você vai obter ['Ze Ruela', 'Ze Mane', 'q', 'u', 'a', 'c', 'k'] sendo que, em mais de 90% dos casos, o que você gostaria de ter seria: ['Ze Ruela', 'Ze Mane', 'quack'].

“Nada” é diferente de “alguma coisa”.

Essa dica é só uma complementação da primeira e da segunda dica.

Quando o seu método/função retorna uma collection (seqüência, conjunto, hash, etc) vazia você deve retorná-la vazia e não um valor sentinela (como None). Isso facilita a vida de quem vai usar o seu método/função:

def vazio():
   return []
 
for elemento in vazio():
   pass #... faz algo se o conjunto contiver dados ...

Se você retorna um valor sentinela:

def vazio():
   return None
 
elementos = vazio()
if elementos:
   for elemento in elementos:
      pass # ...

Notou que tivemos que criar uma variável com o resultado da operação (para não precisar chamá-la duas vezes) e tratar a sentinela com um “if“? Se eu esqueço de tratar a sentinela meu programa vai quebrar.

Lembre-se sempre que uma collection vazia tem valor booleano “False“.

Todo ‘elif‘ tem um irmão ‘else‘.

Sempre que você precisar usar uma construção if/elif coloque uma cláusula ‘else‘.

Além de usar a cláusula ‘else‘ eu geralmente faço com que ela gere uma exceção. Desta forma eu sou obrigado a trabalhar todas as possibilidades nos ‘if/elif‘ evitando ocultar uma situação que pode ser inválida.

class InvalidCommand(Exception):
   pass
 
def minihelp(comando):
   if comando == "print":
      return u"""Imprime dados na tela.
                 Deixará de ser comando no Python 3.0"""
   elif comando == "assert":
      return u"""Certifica se uma condição é
               verdadeira e gera uma excessão em caso contrário"
   elif comando == "...":
      pass # ...
   else:
      raise InvalidCommand(u"Comando %s inválido." % (comando,))

Eu gosto dessa prática mas isso não significa que você deva seguí-la sempre. Existem situações onde ter um “valor default” é necessário e nestes casos o uso do else sem levantar exceção se faz necessário.

if comando == "if":
   print "Vai usar elif?"
elif comando == "elif":
   print "Muito bem. Agora falta o else"
else:
   print "Pronto. Agora está bom."

“Pythonismos”

Use mais atributos públicos do que atributos protegidos (”_“).

Programadores acostumados com Java utilizam muito as cláusulas ‘private‘ e ‘protected‘ para encapsular os atributos de um objeto para logo depois implementarem os getters e setters para acessar esses atributos.

Essa prática é aconselhada em Java porque em algum momento do futuro você, talvez, precise validar esses dados ou retornar valores calculados. Nestes casos os programadores apenas implementam essa lógica nos métodos que acessam o atributo privado.

Mas em Python isso não é necessário. Em Python você pode transformar seu atributo público em uma “property” que não muda a forma de se acessar o atributo e permite o acrescimo de lógica ao acesso do mesmo.

Evite usar “__“.

Por convenção, em Python, todo método ou atributo iniciado com um “_” é considerado privado (equivalente ao protected em Java) e não deve ser acessado de fora da classe mesmo sendo possível fazê-lo.

Dito isso parece meio óbvio que não precisamos usar “__” para dificultar ainda mais o acesso à esse atributo/método. Além disso o uso do “__” traz alguns incoveninentes para quem quer derivar a sua classe e acessar este método/atributo já que o Python o renomeia acrescentando o nome da classe ao seu nome (__attr vira Classe__attr).

Não sobrescreva builtins.

Python disponibiliza várias funções e classes builtins que facilitam muito o uso da linguagem e economizam digitação. Mas esses builtins tem nomes muito “comuns” e frequentemente a gente usa os nomes dos builtins como nomes de identificadores. Eu mesmo vivo (vivia) fazendo isso.

O problema é que em certos momentos alguns problemas podem acontecer quando você tenta chamar um buitin que já não é mais um builtin. Na maioria das vezes o problema “explode” logo e você rapidamente conserta mas em alguns casos você pode perder muitas horas tentando achá-lo.

Algumas pessoas usam um “_” no fim do nome do identificador (ex. “id” vira “id_”) mas eu acho isso um pouco feio então uso só quando não encontro uma alternativa melhor.

Vou colocar aqui uma tabela de equivalências que eu costumo usar para substituir o nome dos builtins mais comumente sobrescritos:

• id – ident, key
• type – kind, format
• object – obj
• list – plural (lista de element vira elements)
• file – fd, file_handler
• dict – dic, hashmap
• str – text, msg

Análise estática economiza seu tempo.

Eu uso o pylint, mas conheço algumas pessoas que preferem o pyflakes ou o PyChecker.

A dica é essa: usar um programinha de análise estática como esses pode diminuir consideravelmente aqueles errinhos chatos de sintaxe, ou de digitação. Pode limpar os ‘import’ desnecessários do seu software, etc, etc.

É lógico que esse tipo de ferramenta não substitui uma boa política de testes mas é um bom complemento para ela.

Challenge yourself

Máximo de 3 níveis de indentação. (ou 4 se estiver dentro de uma classe)

Ao se esforçar para que seu código não fique muito aninhado você está trabalhando melhor a implementação dos seus métodos e funções. Nem sempre é possível (ou aconselhável) restringir tanto o nível de identação do seu código mas muitas vezes isso melhora a sua implementação.

Máximo de 2 indireções.

Recebeu um objeto como parâmetro? Chame apenas métodos dele e evite ao máximo chamar métodos do retorno desses objetos:

def f(obj):
    obj.metodo() # legal!
    obj.metodo().outro_metodo() # ruim!

Quando você chama um método pra um objeto retornado por outro método você está aumentando o acoplamento entre as classes envolvidas impedindo que uma delas seja substituída (ou reimplementada) ‘impunemente’.

Essa regrinha é uma das regrinhas da Lei de Demeter.

Máximo de 0 ‘if/elif/else’s.

Polimorfismo é isso. No mundo OO ideal, perfeito e utópico praticamente não precisaríamos do comando “if” e usaríamos somente polimorfismo. Mas… como não conseguimos isso tão facilmente^* devemos, ao menos, usar o “if” com moderação.

Conclusão

Esta é uma lista incompleta de dicas para programadores Python. Se futuramente eu lembrar ou aprender algo novo eu volto aqui para falar sobre o assunto.

Alguns desenvolvedores podem não concordar com as dicas. Neste caso eles podem enriquecer ainda mais esse texto argumentando sobre o as suas restrições no espaço para comentários.

Se você tiver alguma dica para compartilhar com a gente coloque nos comentários. Se ela for boa mesmo eu coloco ela no corpo principal do blog.

^* eu mesmo só consegui fazer uma aplicação OO funcional sem usar um único if. Era uma implementação do joguinho de adivinhação de animais (aquele que pergunta “Vive na água? (s/n)”) em Smalltalk.

for x in y:
   z+=x[c]*a

for aluno in classe:
  soma_notas += aluno[nota]*peso

if correto:
      === trocentas instruções ===
      return resultado
else:
     return erro

if not correto:
   return erro

=== segue as trocentas instruções normalmente ===

http://pylonshq.com/articles/archives/2009/2/pylons_097_released

Após um grande tempo de espera, foi lançada a versão 0.97 do framework web Pylons As principais mudanças:

1. Agora o WebOb é usado para objetos de requisição e resposta
2. Melhorias de performance na inicialização de objetos
3. Atualização do Beaker e do Routes
4. Melhorias e otimizações nos middlewares

O site do Pylons passou por algumas mudanças algumas semanas atrás, ficou bem bonito e mais organizado. Agora existe uma nova documentação gerada com o Sphinx, e um livro está disponível online, o que deve minimizar os problemas que tinha a documentação. O novo site do Pylons usa o CouchDB como backend, e seu código está disponível em http://bitbucket.org/bbangert/kai/overview/

Outra idéia errada: 1 caractere == 2 bytes

Unicode é uma tabela de codepoints

codificação: neste assunto, codicação não tem nada a ver com cifras ou código-fonte. Uma codificação é apenas uma forma de representar caracteres através de códigos numéricos, para armazenagem em computadores digitais.

A idéia errada: 1 caractere == 1 byte

E o 氣?

[1] na verdade, isso já é uma simplificação; qualquer dicionário de inglês tem a palavra façade (fachada), escrita assim mesmo, com cedilha; a palavra virou até um termo técnico em engenharia de software, pois é o nome de um dos padrões de projeto originais.

[2] \x0C é hexadecimal, em decimal seria 12

[3] a ISO-8859-1 (Latin-1) continua importante até hoje, mas a ISO-8859-5 "não pegou". Os russos preferem outros padrões, como KOI-7 ou KOI-8.

[4] conhecido também como "codepage 1252" ou oficialmente "Windows-1252"

[5] "Seja liberal no que aceita conservador no que envia". Procure "Postel Law" no Google e aprenda um princípio realmente importante e útil para a engenharia e para a vida em sociedade.

class Artigo(models.Model):
 data_publicacao = models.DateTimeField("Data de Publicação", default=datetime.now)
 titulo = models.CharField(max_length=200)
 slug = models.SlugField()
 texto = models.TextField("Texto da noticia")

 class Meta:
     ordering = ['-data_publicacao']
      get_latest_by = 'data_publicacao'

 def __unicode__(self):
     return self.titulo

CREATE FULLTEXT INDEX fti_noticias_artigo ON noticias_artigo(titulo,texto)

objects = SearchManager(('titulo', 'texto'))

Artigo.objects.search('minha busca')

SELECT titulo, data_publicacao, slug, texto, MATCH(titulo, texto) AGAINST ('minha busca')
  AS `relevance`
FROM noticias_artigo
WHERE MATCH(titulo, texto) AGAINST ('minha busca')

Artigo.objects.search('minha busca').order_by('relevance')

cd /usr/share/fonts/truetype
sudo mkdir myfonts
cd myfonts
sudo cp /dados/downloads/Monaco_Linux.ttf .
sudo chown root.root *.ttf
sudo mkfontdir
cd ..
fc-cache

set completion-ignore-case On
"\e[B": history-search-forward
"\e[A": history-search-backward

set completion-ignore-case On
"\e[B": history-search-forward
"\e[A": history-search-backward

sudo aptitude install texlive texlive-humanities latex-beamer abntex aspell-pt-br \
gedit-plugins rubber texmaker

Webcam: 
sudo aptitude install cheese

Man colorido
- instalar most
- sudo update-alternatives --config pager

Configurar Skype
- A definir: como fazer o mic interno funcionar

Python: 
sudo aptitude install ipython
- baixar e instalar o wind-ide-101

Gedit: 
- ativar plugins e modificar configurações (pendente)
- Utilizar fonte Monaco
- instalar plugins: latex open_terminal better_python_console
- gedit-latex-plugin_0.1.3.1-2~0ubuntuitdev1_i386.deb

Gnome-do:

sudo aptitude install gnome-do gnome-do-plugins

sudo aptitude install nautilus-open-terminal
- baixar e instalar
-- nautilus-send-gmail_0.1.1-1_all.deb
-- nautilus-rename-exif-date_0.1.1-1_all.deb - trocar linhas:
-- Alterar o programa /usr/lib/nautilus/extensions-2.0/python/nautilus-rename-exif-date.py
    def menu_activate_cb(self, menu, names):
        """Called when the user selects the menu. Rename the selected files."""
        for path in names:
            img_file = open(path, "rb")
            tags = EXIF.process_file(img_file)
            date = str(tags["EXIF DateTimeOriginal"]).replace(":", "-", 2)
            date = date.replace(":", "", 1)
            date = date.replace(":", "", 1)
            date = date.replace(":", "",1)
            date = date.replace(" ", "-",1)

            dir_name = os.path.split(path)[0]
            file_name = os.path.split(path)[1]
            parts = file_name.split(".")
            if len(parts) == 1:
                extension = ""
            else:
                extension = "." + parts[-1].lower()
            os.rename(path, dir_name + "/" + date + extension)
Adicionar scripts a ~/.gnome2/nautilus-scripts (menu de contexto)

Desinstalar:
-sudo aptitude remove evolution ekiga

• Outro teste de nerd
• Todos os testes publicados aqui

Yep, that's the second time I post a "Hello world" entry here. The reason is that I recently moved my domain from an account at Bluehost to a VPS at Linode. So, first of all, I would like to introduce you to merlin, my new VPS. :)

As I'm the sysadmin behind my server now, I decided to not install mod-php here and then I had to change my blog engine. I used to run Wordpress for years and now I'm running django-diario, a wonderful blog engine for django made by Brazilian djanglers.

About this new version of my old blog, you may have noticed that it has only this post... That's right, I removed the old stuff (in fact I just didn't migrate them from Wordpress) and I intend to start translating and re-posting a small part of them as soon as possible. If you want to see here any specific post from my old blog, please, let me know.

As you can see now I'm writing in English and I used to write in Portuguese... I'm not a professional English writer, so you won't be a lucky guy if you find some bugs around here and if you do find something, please, let me know about it and I will gladly fix it.

You'll probably see at here lots of posts about python and debian. This time I'll also try to write more often and in small chunks. :)

I think that's all...

Every month the GruPy-SP members get together to discuss, chat and/or code.

This month we will meet to watch/present some lightning talks and to talk about our participation at the Fórum Internacional de Software Livre (FISL 10).

The meeting will be hold at the SP HackLab, May 23. More details (in pt-br): GruPy-SP wiki.

See you there

In my previous post I made an open statement which I’d like to clarify a bit further:

(…) when the rules don’t work for people, the rules should be changed, not the people.

This leaves a lot of room for personal interpretation of what was actually meant, and TIm Hoffman pointed that out nicely with the following questioning in a comment:

I wonder when the rule is important enough to change the people though. For instance [, if your] development process is oriented to TDD and people don’t write the tests or do the job poorly will you change them then?

This is indeed a nice scenario to explore the idea. If it happens at some point that a team claims to be using TDD, but if in practice no developer actually writes tests first, the rules are clearly not working. If everyone in the team hates doing TDD, enforcing it most probably won’t show its intended benefits, and that was the heart of my comment. You can’t simply keep the rule as is if no one follows it, unless you don’t really care about the outcome of the rule.

One interesting point, though, is that when you have a high level of influence over the environment in which people are, it may be possible to tweak the rules or the processes to adapt to reality, and tweaking the processes may change the way that people feel about the rules as a consequence (arguably, changing people as a side effect).

As a more concrete example, if I found myself in the described scenario, I’d try to understand why TDD is not working, and would try to discuss with the team to see how we should change the process so that it starts to work for us somehow. Maybe what would be needed is more discussion to show the value of TDD, and perhaps some pair programming with people that do TDD very well so that the joy of doing it becomes more visible.

In either case, I wouldn’t be simply asking people “Everyone has to do TDD from now on!“, I’d be tweaking the process so that it feels better and more natural to people. Then, if nothing similar works either, well, let’s change the rule. I’d try to use more conventional unit testing or some other system which people do follow more naturally and that presents similar benefits.

• SCS2009 - Semana de Computação da SOCIESC 2009
• Senra em: a trajetória de um profissional da computação
• Vídeos da PyCon 2009

For a long time I’ve been an advocate of Python’s notion of controlling access to private and protected members (attributes, methods, etc) with conventions, by simply naming them like “_name”, with an initial underline.  Even though Python does support the “__name” (with double underscore) for “private” members (this actually mangles the name rather than hiding it), you’ll notice that even this is rarely used in practice, and the largely agreed mantra is that convention should be enough and thus one underscore suffices. This always resonated quite well with me, since I generally prefer to handle situations by agreement rather than enforcement. Well, I’m now changing my opinion.that this works well for this purpose, at least in certain situations.

This methodology may work quite well in situations where the code scope is within a very controlled environment, with one or more teams which follow strictly a single development guideline, and have the power to refactor the affected code base somewhat easily when the original decisions are too limiting.

Having worked on a few major projects now, and some of them being libraries which are used by several teams within the same company or outside, I now perceive that people very often take shortcuts over these decisions for getting their job done quickly. It’s way easier to simply read the code and get to the private guts of a library than to try to get agreement over the right way to do something, or sending a patch with a suggested change which was carefully architected.

Many people by now are probably thinking: “Well, that’s their problem, isn’t it? If their code base breaks on the next upgrade they’ll get burden and won’t be able to upgrade cleanly.”, and I can honestly understand this feeling, since I shared it. But, for a number of reasons, I now understand that this isn’t just their problem, it’s very much my problem too.

Most importantly, on any serious software, these problems will usually come back to the implementors, and many times the problem will have a much larger magnitude by then than they had at the time a change could have been done “the right way” on the implementation, because code dependent on the private bits will have settled.

Most people are optimist by nature and believe that the implementation won’t change, but, of course, one of the reasons why private information is made private in the first place is exactly because the implementor believes that having the freedom to change these details in the future is important, and not rarely there’s already a plan of evolution in place for these private pieces, which may include revamping the implementation entirely for scalability or for other goals.

In the best case, the careless people will get burden on the upgrade and will ask for support or simply won’t upgrade silently, and both cases hurt implementors, because providing support for broken software takes time and energy, and amazingly can even hurt the software image. Lack of upgrades also means more ancient versions in the wild to give support for. Besides these, in the worst case scenario, the careless people have enough influence on the affected project to cause as much burden on it as if the private data was public in the first place.

As much as I’m a believer in handling situation by agreement rather than enforcement, I’m also a believer that when the rules don’t work for people, the rules should be changed, not the people. So my positioning now is that the language supported access constraints (public, protected, private), as available in languages like Java and C++, are a better alternative when compared to convention as used today in Python, since they provide an additional layer of encouragement for people to not break the rules carelessly, and that helps in the maintenance and reuse of software that has greater visibility.

wm title . Hello
grid [ button .bt -text { Olá Mundo! } -command exit ]

#!/bin/sh
#\
exec wish "$0" "$@"

wm title . Hello
grid [ button .bt -text { Olá Mundo! } -command exit ]

Estive pesquisando esses dias sobre o Rails (www.rubyonrails.org) e não existe um jeito muito fácil de instalar a versão mais nova do Rails (2.3), no Ubuntu 8.10, sem meter a mão na massa um pouco. Depois de vários testes percebi um caminho menos traumático.

Um “erro” comum é o “Invalid Rdoc Format”, devido a defasagem do Rdoc em relação ao Rake, e quando se tenta instalar o Rake este dispara o “Warning” mencionado.

Eis o “quicktour” que utilizei:

Instalar o pacote inicial do ruby

$ sudo aptitude install ruby ruby-dev libruby libreadline-ruby libopenssl-ruby irb ri rdoc

Instalar o suporte a sqlite3, padrão para o Rails 2.3

$ sudo aptitude install libsqlite3-ruby

Instalar o rubygems a partir do fonte

$ wget http://rubyforge.org/frs/download.php/56227/rubygems-1.3.3.tgz
$ tar -zxvf rubygems-1.3.3.tgz
$ cd rubygems-1.3.3
$ sudo ruby setup.rb
$ cd /usr/local/bin
$ sudo ln -s /usr/bin/gem1.8 gem

Atualizar o rdoc para não dar o erro mencionado acima

$ sudo gem install rdoc

Instalar o Rails

$ sudo gem install rails

Para iniciar rapidamente um projeto Rails e testar se está tudo funcionando faça

$ cd ~
$ rails projeto
$ cd projeto
$ ruby script/server

Agora acesse no seu browser http://localhost:3000

Olá pessoas,

Tirando a poeira aqui do blog pra anunciar meu novo toy project cujo anuncio deveria ser feito só quando eu tivesse algum resultado concreto, mas com o animo na evolução de hoje resolvi publicar logo.

Tenho atualizado o meu twitter bem mais vezes que esse blog pela facilidade que é twittar (principalmente quando você tem um plugin pra seu browser como eu). Lá fico sempre atualizando sobre o que estou fazendo, como as coisas no projeto estão indo, referências a sites onde aprendi a usar o motor de passo, transistores, etc.

Como você leu no fim do parágrafo anterior, o meu novo projeto é relacionado a robótica e microeletrônica. A idéia principal é fazer o meu arduino se comunicar com dispositivos móveis como celulares symbian e internet tablets através de qualquer protocolo, seja ele “wired” ou não.

Pra comecar a brincadeira comprei um módulo bluetooth chamado BlueSMIRF Gold que implementa toda a stack bluetooth e para integrar ao seu arduino basta você ligar o TX do BlueSMIRF no RX do arduino, e o RX no TX do mesmo. Ligando também o pino Vcc do módulo em uma tensão de 5v (que pode ser o pino 5v do arduino) e o GND no terra, você já pode parear o bluesmirf com seu computador e abstrair a conexão bluetooth como sendo uma porta serial, simples assim. Pretendo fazer um outro post ou um artigo no site do marmota detalhando a ligação desse módulo assim que aprender mais sobre ele.

Sim, e antes que eu me esqueca, eu terminei pagando muito caro por esse BlueSmirf. Fora os 60 dólares do módulo, paguei 30 dólares pela entrega e ainda tive o azar do módulo ter parado na Receita. Lá se foram mais 120 reais de imposto, e no fim eu não quis nem somar as despesas e saber quanto o bichinho saiu pra mim.

Comprei também um ProtoShieldBR do gaúcho Rafael Quines que fez um excelente trabalho no desenvolvimento desse shield. A idéia básica do ProtoShieldBR é ser uma plaquinha de propósitos gerais, cheias de barramento onde você vai posicionando os seus componentes da maneira que achar melhor - estilo protoboard - só que em cima do seu arduino. Se não fosse o meu ferro de solda de 5 reais as soldas teriam ficado bem bonitinhas e o resultado final teria sido mais bacana.

Voltando pra os objetivos do toy project; O pontapé inicial do Marmota é fazer um carrinho de controle remoto controlado por um celular s60 através do bluetooth usando python. A parte “física” do carro já tá pronta e hoje consegui comandá-lo via bluetooth usando pySerial no meu notebook. Já fiz também a interface da aplicação PyS60, faltando só criar a classe de socket bluetooth do celular. Falta também dar uma regulada no motor de passo responsável pelo direcionamento do carro, mais algumas colas e soldas, e rodas emborrachadas pra ter uma tração maior com o chão.

Tenho já algumas idéias de interação do arduino com internet tablets, andei pesquisando sobre shields ethernet e até vi que já fizeram um webserver simples pra ele. Já pensou você controlando luzes, alarmes, cameras de vigilância e etc tudo no seu browser aonde você estiver e o arduino do outro lado dando conta de tudo? Show de bola.

Pra finalizar, quem quiser debater, ajudar, dar mais idéias e etc, dê uma lida no site do Marmota. Prometo atualizar ele com fotos, videos e códigos tanto do lado arduino como a aplicação pys60 do lado mobile quando esse primeiro projeto for finalizado. Quem quiser acompanhar mais de perto os passos pra finalização desse projeto, siga-me no twitter!

É isso, até a próxima pessoal

>>> import readline
>>> readline.parse_and_bind("tab: complete")
>>>

>>>
Display all 161 possibilities? (y or n)

PYTHONSTARTUP=<(echo 'import readline, rlcompleter; readline.parse_and_bind("tab: complete")') python

Um dos maiores desafios da criação de Portais Corporativos é a integração de serviços. Na era pré wsgi e deliverance, tinhamos que escrever muitos "corretivos" para integrar uma aplicação e com a dupla wsgi/deliverance isso tudo mudou.

A Liberiun que vem usando essa dobradinha a um bom tempo e seus frutos são inegáveis!

O antigo blog da Liberiun era feito utilizando uma solução caseira, e atendia a nossa demanda parcialmente, de forma que estudamos muito a sua mudança. Estudos aqui, estudos ali, e escolhemos o Zine para ser nossa aplicação de blog do portal.

A escolha do Zine foi em função de ele ser uma aplicação Python, ser padrão WSGI e ter um skin muito tranquilo para trabalhar com o Deliverance.

Em resumo: Nós estamos utilizando Zine para blogs e novas integrações serão feitas!

Até mais,

Fábio Rizzo
Vice-Presidente Executivo
fabiorizzo@liberiun.com

Olá,

falar sobre workflow (BPM) pode fazer sentido para muita gente, mas nem para todos. Nada como ver uma ilustração não.

Uma vez fui desenhar um workflow e uma pessoa me perguntou brincando: "Você acha que eu não consigo entender sem você desenhar?". A resposta foi: "Não, sou eu quem não consigo explicar sem desenhar".

Então se você, como eu, concorda com isso, você vai gostar do DCWorkflowGraph. Ele é apenas um produto que faz um desenho de qualquer workflow que exista no seu Plone Site.

Baixe em: http://plone.org/products/dcworkflowgraph

Ele possui apenas uma dependência, o Graphviz.

Mas a instalação é simples e está no README do Graphviz.

Assim que você instalar vai ver uma nova aba quando visualizar um workflow, é onde vai estar a ilustração.

Um abraço.

Olá pessoal,

é um prazer falar sobre o nosso repositório! Temos criado várias soluções e disponibilizado no seguinte endereço: code.liberiun.com:7777/.

Entre as soluções que temos desenvolvido estão:

• Liberiun Portal Varnish Cache Manager - uma solução de inteligência entre cache e aplicação
• Liberiun Portal Banner - solução de Banners utilizada em nossos projetos
• Lineriun Portal Intranet - framework utilizado na criação de Intranets
• Liberiun Portal Licita - uma solução para portais de utilizam divulgação de licitações
• Liberiun Portal News - Mailing e Notícias, uma solução para mehorar as suas notícias e enviá-las ao público do seu portal
• Liberiun Portal Streaming - solução de streaming para portais
• Liberiun Portal Utils - framework com os métodos utilizados no cotidiano do desenvolvimento de portais

A política de desenvolvimento de software é norteada pela diretiva de desenvolvimento de soluções livres e de código aberto. Mas como isso funciona na prática?

Nós desenvolvemos uma solução, que surge de uma necessidade interna ou externa, e disponibilizamos a solução e seu código fonte, sem a cobrança de licenças.

Os softwares são utilizados em clientes, ou projetos Plone que não tenhamos atuado diretamente. E este uso gera melhorias, uma evolução natural do software, e com frequência somos procurados para implementar melhorias nos softwares. Então se um cliente X paga por esta melhoria, o cliente Y que utiliza a mesma solução também tem esta nova funcionalidade, porém sem custos. E você que pode não necessariamente é cliente da Liberiun, também ganha a nova funcionalidade sem custos.

Este ciclo têm gerado evoluções em várias de nossas soluções. Entre elas as que temos desenvolvido para grande cases.

Tudo está sendo disponibilizado neste repositório, e vou falar em detalhes sobre cada solução nos próximos posts.

Um abraço.

Olá,

com a chegada do geração Plone 3 um novo conceito apareceu, as famosas Viewlets. São componentes Zope 3 (explico em um post focado neste assunto) utilizados para melhorar alguns aspectos da reenderização de um Portal Plone, como:

• Performance, implementações Zope 3 são naturalmente mais leves, rápidas (use!);
• Migração, através das Viewlets você não precisa mais customizar o template principal do Plone (main_template.pt);
• Gerenciamento via interface, você pode através de um simples clique esconder alguma parte do layout original.

Olá,

uma das soluções que desenvolvemos é o Liberiun Portal News, esta solução surgiu de alguns projetos combinados com necessidades internas.

Vamos a descrição das features da solução:

Um novo tipo Imagem

Que é configurável, você pode:

• desabilitar a imagem padrão do Plone (para não confundir o usuário final)
• habilitar a página de direitos autorais (exibida quando a imagem full size é exibida, você concorda e só então pode ver a imagem)

Que basicamente tem habilitada a funcionalidade descrita abaixo 

É um mecanismo automático de organização das notícias, ele (caso acionado, não é padrão) verifica se existe esta estrutura:

2009 (ou ano corrente) > março (ou mês corrente) > dia corrente > aqui é criada a notícia

Caso não exista a estrutura, ele cria a estrutura e depois a notícia. Esta estrutura é configurável, você cria como quiser.

Ele envia newsletter, e tem algumas configurações.

Cadastro

Existe um cadastro para o envio, neste cadastro você escolhe entre 2 tipos de cadastros, um simples (com nome e e-mail) e outro com mais campos(como sexo, idade, estado e cidade), isto para que seja possível efetuar envios segmentando o público alvo

Envio

Você pode dizer quem são:

• Remetente
• Assunto do e-mail
• Imagem de cabeçalho do e-mail
• O texto do cabeçalho do e-mail
• O texto do rodapé do e-mail
• Filtros

Você ainda pode filtrar:

• As notícias que serão enviadas (por período)
• O público alvo
• Periodicidade

Você pode dizer com qual periodicidade você quer que o Portal envie a newsletter

Esse mecanismo é feito justamente para quem tem Notícias em outra plataforma/sistema e agora está usando Plone, porém quer manter seu histórico de notícias no novo Portal. Ele utiliza um arquivo XML com os dados, facilmente gerado, e com estrutura flexível.

Nele você pode apontar:

• Se a notícia que será importada vai ser importada como a notícia do liberiun.portal.news, ou se vai ser importada como a notícia padrão do Plone
• Qual é o arquivo XML
• Se você deseja que as tags HTML que possam existir devem ser removidas
• Se deseja a criação da estrutura de pastas
• Qual é a pasta do Portal que vai receber os objetos criados
• Por último, você mesmo diz qual é a estrutura do XML desejada

Bem vindos ao nosso novo Portal!

Uma das inovações é o novo Portal, que traz uma nova tecnologia o Deliverance (WSGI), e aproveitando a mudança tecnologica renovamos também o layout do Portal.

O Deliverance é um produto que torna desnecessária a criação de uma Skin Plone, o trabalho de integração que fazia o Plone assumir outra característica visual foi exponencialmente resumido. E grande parte do esforço em pequenos e médios Portais se concentrava nisso, porém com o Deliverance isto não acontece mais.

O trabalho com Deliverance baseia-se na idéia mapear os estilos do Plone com os arquivos de aparência do Portal (CSS), o trabalho é simples você tem que dizer ao Deliverance que o estilo portal-column-content do Plone corresponde ao estilo corpo do novo layout (no nosso caso).

São várias as novidades do portal, um destaque maior para as turmas de treinamento é um dos principais, a nova home destaca as informações mais procuradas dentro do Portal, entre outras novas idéias.

Porém o que me deixa mais estusiasmado é o nosso "novo" (entre aspas pois tem quase 1 ano de vida, sem divulgação) Repositório de Produtos Open Source!

Nele existem diversas ferramentas, para Notícias & Newsletter, para Gerenciamento Inteligente de Cache, para Banners, para Sistemas de Licitação, produto para Agendamento de reuniões, produto para Intranets, entre outros.

Todos eles serão divulgados individualmente no nosso novo Portal, vou falar sobre cada uma das features e características contidas em cada um.

Além disso vamos mostrar alguns do nossos Cases (features desenvolvidas, objetivos alcançados, prints de tela, etc ...), um dos mais esperados é a Intranet da Caixa Econômica Federal, que está em desenvolvimento. Um grande projeto que exige inovação e renovação, estamos trabalhando em soluções Open Source para melhorar algumas questões do Plone, isto pois o cenário do Projeto (130 mil usuários e 5000 gestores de conteúdo autenticados através do AD Corporativo) exige uma performance maior do que a existente hoje no Plone, com certeza estamos falando de um dos maiores projetos Plone do Mundo.

Todos os produtos de melhoria tecnológica que estamos fazendo estarão disponíveis no nosso repositório, e vou falar de cada um deles, um post para cada novo produto.

Você já pode acessar nosso repositório em:

code.liberiun.com:7777/

Estamos utilizando o Mercurial (hg) [1] ao invés do habitual Subversion, mas isto é assunto vai ser postado pelo Douglas.

Deixo apenas a dica, um client dele no Windows (um dos motivos do uso, cross plataform), você pode baixar em: bitbucket.org/tortoisehg/stable/wiki/install

Um abraço.

[1]

• en.wikipedia.org/wiki/Mercurial_(software)
• www.selenic.com/mercurial/wiki/

A Liberiun está lançando seu novo site e posso dizer que estou muito empolgado com esse lançamento pelos seguintes motivos:

• Totalmente feito usando Plone 3.2;
• Totalmente WSGI;
• Skin implementada em Deliverance;
• Totalmente acessível (DaSilva) e validado W3C;

A versão do site está baseado no Plone 3.2 e na futura arquitetura do Plone 4, trazendo benefícios nunca antes possíveis para o Plone.

O site ainda tem muitas funcionalidades para serem exibidas, mas isso é assunto para o próximo post.

Fábio Rizzo
Vice-Presidente Executivo
fabiorizzo@liberiun.com