Decken no PyPI

O Decken já pode ser testado no Linux. Ainda é versão bem inicial, com poucas funcionalidades e quase nada no menu funciona e o que tem lá é provisório.

Utilizem o easy_install para instalar a aplicação. No Ubuntu e Debian, vocês podem baixar esse instalador de pacotes Python assim:

sudo apt-get install python-setuptools

Depois disto bastam os seguintes comandos:

sudo easy_install DeckenMagicPlugin

sudo easy_install Decken

Ainda na linha de comando, para iniciar a aplicação execute: decken_script.

Ao iniciar a aplicação ele já começa atualização das coleções de cards de Magic. Caso você precise fechar a aplicação antes de concluir as atualizações, não tem problema. No menu Edit há o comando para baixar as atualizações. Ele continua de onde parou.

O caminho ainda é longo para ter uma aplicação de fato útil.

Decken no Launchpad

Havia prometido publicar o codigo-fonte do MaginBook (agora Decken) somente quando o mesmo atualizasse sua base de dados sozinho. Ele ainda não faz isso, mas publiquei o código com que venho trabalhando e há scripts para realizarem esta tarefa. De qualquer modo, o arquivo database.db já vem com o cadastro de uma grande quantidade de cards de Magic, então não haverá problemas com isso. Uma vez que ele esteja executando, baixará automaticamente as imagens.

Vocês podem ver e baixar o código aqui. Lá vocês encontraram o Decken propriamente dito e mais o plugin para Magic.

Quando baixarem o plugin, não esqueçam de executar python setup.py develop dentro da pasta.

Vocês terão mais chances de executar o programa no Linux, ok? Pelo fato de está trabalhando no Mac ainda não tenho noção de quais os nomes das dependências via apt-get (no Ubuntu) eu preciso baixar. Tenho de informar no setup.py do Decken quais dependências ele deve baixar via easy_install. Por enquanto, só informei uma dependência: BeautifulSoup.

Depois que eu tiver com um programa capaz de ser funcional e instalável via easy_install, informo por aqui.

MaginBook sem a infra do Lackey

Mudei de idéia em relação a usar a infraestrutura do LackeyCCG.

Optei por implementar um plugin que dado uma lista de siglas de sets de Magic, acesse um site e carregue as informações dos cards, gravando-as num banco de dado SQLite. Foi uma escolha mais divertida.

Outra vez a biblioteca BeautifulSoup foi incrível. Navegar na árvore de tags HTML e extrair os dados é moleza com ela.

Glade, Mac OS e MaginBook

Ora, as coisas não poderiam ficar melhores. Depois do trabalho de pesquisa que estava tendo para fazer certas coisas com Gtk, descobri que seria possível utilizar o Glade no Mac OS X. Baixei o binário e problema resolvido.

O trabalho é devagar, pois procuro o melhor jeito para desenvolver o MaginBook. Além de um tutorial ou outro sobre Gtk e Glade, consegui um exemplo inesperado, um organizador de decks e cards feito em Python com Gtk! O criador do Magiclibrary escreveu um comentário num post anterior sobre este assunto. Fui atrás dos códigos-fonte da aplicação para saber como ele resolveu certas coisas. O bacana é que ele também utilizou o Glade como ferramenta para montar a interface gráfica.

Só lembrando a vocês que só vou disponibilizar o código da aplicação quando ela estiver conseguindo baixar a descrição das cartas e suas imagens.

Além do mais, é importante salientar que vou usar a infra-estrutura de plugins do LackeyCCG, onde já se fornece praticamente tudo: informações sobre blocos, edições, descrição das cartas e imagens.

Organizador de Decks em Python

Tenho um Nokia N800 que está parado deste que resolvi adotar uma agenda não-eletrônica. O fato do tablet não ter uma bateria de uma boa duração, muitas vezes não tinha a agenda disponível quando realmente precisava.

Bom, desde então fiquei pensando numa maneira de torná-lo útil novamente. Como eu jogo Magic The Gathering, um jogo de cartas colecionáveis, seria interessante ter uma lista de cartas e decks sempre à mão.

As funcionalidades que pretendo implementar para este organizador de decks, que chamarei de Maginbook:

• Pesquisa de cartas
• Download de novas cartas
• Criar e baixar decks da Internet
• Exportar decks para programas como MWS, LackeyCCG e Apprentice
• Cotação das cartas

Eu comecei a testar as bibliotecas necessárias para este trabalho. Depois publico o código em algum repositório. Haverá duas versões: uma para Linux/Mac e outro para o Nokia N800 e outros tablets da linha.

DiceDnd 1.1

Depois de um final de semana complicado e acamado, voltei a escrever na segunda-feira os melhoramentos do DiceDnd. Pretendia melhorar o visual, habilitar o modo fullscreen e ainda fazer um pacote debian para distribuir o programa. Devido às dificuldades encontradas, fiquei somente no melhoramento visual. Pois bem, tirei umas fotos do aplicativo funcionando (não descobri uma função print screen no N800) e ainda estou disponibilizando uma nova versão abaixo.

Vou ficar devendo o fullscreen e o pacote.

DiceDnd no Nokia N800

DiceDnD com o resultado da jogada de dados

fonte do dicednd.py (atualizado)

#!/usr/bin/python2.5

import osso
import gtk
import hildon

def labela(texto):
    fonte = '%s'
    etiqueta = gtk.Label(fonte % texto)
    etiqueta.set_use_markup(True)
    return etiqueta

def string_jogada(vezes, dado, soma):
    if soma > 0:
        sinal = '+'
    elif soma == 0:
        sinal = ''
    else:
        sinal = '-'
    return '%dd%d%s%s' % (vezes, dado, sinal, abs(soma) or '')

class DiceDnD(hildon.Program):
    def __init__(self):
        self.dado_atual = 0
        self.vezes = 0
        self.soma = 0
        hildon.Program.__init__(self)
        self.window = hildon.Window()
        self.window.set_title('DiceDnd')
        self.window.set_border_width(40)
        self.window.connect("destroy", self.quit)
        self.add_window(self.window)

        tabela = gtk.Table(5,4,False)
        self.window.add(tabela)        

        self.dado4 = gtk.Button()
        self.dado4.add(labela('4'))
        self.dado6 = gtk.Button()
        self.dado6.add(labela('6'))
        self.dado8 = gtk.Button()
        self.dado8.add(labela('8'))
        self.dado10 = gtk.Button()
        self.dado10.add(labela('10'))
        self.dado12 = gtk.Button()
        self.dado12.add(labela('12'))
        self.dado20 = gtk.Button()
        self.dado20.add(labela('20'))
        self.botaoMais = gtk.Button()
        self.botaoMais.add(labela('+'))
        self.botaoMenos = gtk.Button()
        self.botaoMenos.add(labela('-'))
        self.botaoJogar = gtk.Button()
        self.botaoJogar.add(labela('Jogar'))
        self.frame = gtk.Frame()
        self.montagem = gtk.Label('Jogada')
        self.frame.add(self.montagem)

        tabela.attach(self.dado4,0,1,0,1)
        tabela.attach(self.dado6,1,2,0,1)
        tabela.attach(self.dado8,2,3,0,1)
        tabela.attach(self.dado10,0,1,1,2)
        tabela.attach(self.dado12,1,2,1,2)
        tabela.attach(self.dado20,2,3,1,2)
        tabela.attach(self.botaoMais,0,1,2,3)
        tabela.attach(self.botaoJogar,1,2,2,3)
        tabela.attach(self.botaoMenos,2,3,2,3)
        tabela.attach(self.frame,0, 3, 3, 4)

        self.dado4.connect('clicked',self.preparar,4)
        self.dado6.connect('clicked',self.preparar,6)
        self.dado8.connect('clicked',self.preparar,8)
        self.dado10.connect('clicked',self.preparar,10)
        self.dado12.connect('clicked',self.preparar,12)
        self.dado20.connect('clicked',self.preparar,20)
        self.botaoMais.connect('clicked',self.incrementar,1)
        self.botaoMenos.connect('clicked',self.incrementar,-1)
        self.botaoJogar.connect('clicked',self.mostrar)

        self.window.show_all()

    def mostrar(self, button):
        if self.dado_atual == 0:
            return
        import random
        total = 0
        for i in range(self.vezes):
            total += random.randint(1,self.dado_atual)
        total = total + self.soma
        jogada = string_jogada(self.vezes, self.dado_atual, self.soma)
        self.show_message('%s' % total)

    def preparar(self, button,valor):
        if valor  self.dado_atual:
            self.dado_atual = valor
            self.vezes = 1
            self.soma = 0
        else:
            self.vezes += 1
        self.montagem.set_text(string_jogada(self.vezes, self.dado_atual, self.soma))

    def incrementar(self, button,valor):
        self.soma = self.soma + valor
        self.montagem.set_text(string_jogada(self.vezes, self.dado_atual, self.soma))

    def show_message(self, message):
        dlg = hildon.Note('information', (self.window, message))
        dlg.run()
        dlg.destroy()
        #pango_markup = '%s\n%s' % ('DiceDnD', message)
        #hildon.hildon_banner_show_information_with_markup(gtk.Label(''), None, pango_markup)

    def quit(self, evt):
        gtk.main_quit()

    def run(self):
        gtk.main()

def main():
    prog = DiceDnD()
    prog.run()

if __name__ == "__main__":
    main()

DiceDnd

Os dados usados no RPG D&D

A minha idéia exploratória de criar um aplicativo para gerar jogada de dados no meu N800  ocupou umas horas da noite de sexta e início de madrugada do sábado.

O objetivo da aplicação é bem simples. Eu vou voltar a mestrar campanhas de RPG. Comprei o recente D&D 4ª Edição em português mais uma aventura para personagens iniciantes. Não tenho todos os tipos de dados necessários. São 6 tipos, por quantidade de faces: 4, 6, 8, 10, 12 e 20. Assim, queria simular a parada de dados pelo meu N800, um internet tablet da Nokia.

Uma das principais linguagens para programar nesses dispositivos é Python. Apesar de não conhecer muito a biblioteca Gtk (biblioteca gráfica), conheço a linguagem razoavelmente bem, por isso acreditava que conseguiria implementar o aplicativo no final de semana.

A primeira providência foi procurar documentação. A idéia do projeto já estava toda na minha cabeça mas não sabia por onde começar. Depois de um tempo, encontrei algumas coisas. Foram importantes os seguintes documentos:

• http://www.pygtk.org/pygtktutorial/
• http://pymaemo.garage.maemo.org/documentation.html
• http://gpodder.org/ (seu código-fonte)

A versão do sistema operacional é o OS 2008 (Diablo). O Python 2.5 já estava instalado. De fato, não precisei instalar outra coisa. Algumas documentações diziam que eu tinha de instalar o interpretador da linguagem. Talvez eu tenha feito isso algum tempo atrás.

Outra coisa que ajudou bastante, para ir escrevendo e testando rapidamente, foi acessar via SSH o dispositivo pelo Nautilus (num notebook com Ubuntu). Criei o arquivo da aplicação no cartão do N800 e depois abrir com o editor TextFlow. Daí era só escrever, salvar e ir no PDA executar a aplicação.

O cliente e servidor do SSH não vem instalado por default no N800. Nem o terminal. Por ele é que eu rodava o Python. Pelo notebook, eu usava também um terminal para acessar o N800 via ssh. Era útil para testar algumas coisas no interpretador interativo do Python.

As próximas tarefas envolvem melhorar o aspecto visual da aplicação e preparar um instalador para ficar mais fácil de dispobilizar. O código-fonte encontra-se abaixo:

#!/usr/bin/python2.5

import osso
import gtk
import hildon

def string_jogada(vezes, dado, soma):
    if soma > 0:
        sinal = '+'
    elif soma == 0:
        sinal = ''
    else:
        sinal = '-'
    return '%dd%d%s%s' % (vezes, dado, sinal, abs(soma) or '')

class DiceDnD(hildon.Program):
    def __init__(self):
        self.dado_atual = 0
        self.vezes = 0
        self.soma = 0
        hildon.Program.__init__(self)
        self.window = hildon.Window()
        self.window.set_title('DiceDnd')
        self.window.connect("destroy", self.quit)
        self.add_window(self.window)

        tabela = gtk.Table(5,4,True)
        self.window.add(tabela)

        self.dado4 = gtk.Button('4')
        self.dado6 = gtk.Button('6')
        self.dado8 = gtk.Button('8')
        self.dado10 = gtk.Button('10')
        self.dado12 = gtk.Button('12')
        self.dado20 = gtk.Button('20')
        self.botaoMais = gtk.Button('+')
        self.botaoMenos = gtk.Button('-')
        self.botaoJogar = gtk.Button('Jogar')
        self.frame = gtk.Frame()
        self.montagem = gtk.Label('Jogada')
        self.frame.add(self.montagem)

        tabela.attach(self.dado4,0,1,0,1)
        tabela.attach(self.dado6,1,2,0,1)
        tabela.attach(self.dado8,2,3,0,1)
        tabela.attach(self.dado10,0,1,1,2)
        tabela.attach(self.dado12,1,2,1,2)
        tabela.attach(self.dado20,2,3,1,2)
        tabela.attach(self.botaoMais,0,1,2,3)
        tabela.attach(self.botaoJogar,1,2,2,3)
        tabela.attach(self.botaoMenos,2,3,2,3)
        tabela.attach(self.frame,0, 3, 3, 4)

        self.dado4.connect('clicked',self.preparar,4)
        self.dado6.connect('clicked',self.preparar,6)
        self.dado8.connect('clicked',self.preparar,8)
        self.dado10.connect('clicked',self.preparar,10)
        self.dado12.connect('clicked',self.preparar,12)
        self.dado20.connect('clicked',self.preparar,20)
        self.botaoMais.connect('clicked',self.incrementar,1)
        self.botaoMenos.connect('clicked',self.incrementar,-1)
        self.botaoJogar.connect('clicked',self.mostrar)

        self.window.show_all()

    def mostrar(self, button):
        if self.dado_atual == 0:
            return
        import random
        total = 0
        for i in range(self.vezes):
            total += random.randint(1,self.dado_atual)
        total = total + self.soma
        jogada = string_jogada(self.vezes, self.dado_atual, self.soma)
        self.show_message('%s' % total)

    def preparar(self, button,valor):
        if valor  self.dado_atual:
            self.dado_atual = valor
            self.vezes = 1
            self.soma = 0
        else:
            self.vezes += 1
        self.montagem.set_text(string_jogada(self.vezes, self.dado_atual, self.soma))

    def incrementar(self, button,valor):
        self.soma = self.soma + valor
        self.montagem.set_text(string_jogada(self.vezes, self.dado_atual, self.soma))

    def show_message(self, message):
        dlg = hildon.Note('information', (self.window, message))
        dlg.run()
        dlg.destroy()
        #pango_markup = '%s\n%s' % ('DiceDnD', message)
        #hildon.hildon_banner_show_information_with_markup(gtk.Label(''), None, pango_markup)

    def quit(self, evt):
        gtk.main_quit()

    def run(self):
        gtk.main()

def main():
    prog = DiceDnD()
    prog.run()

if __name__ == "__main__":
    main()

Idéia exploratória

Uma boa idéia me surgiu agora, útil para o momento e ótima pedida para iniciar a exploração no mundo da programação de dispositivos Nokia que usam o sistema operacional Maemo: um rolador de dados.

Bobo, né? Inclusive, acho que já existe um. Mas é diferente do que eu estou pensando.

Gostaria que a tela do aplicativo mostrasse um quadrado com todos os tipos de dados usados no RPG D&D ou seja, os de 4, 6, 8, 10, 12 e 20 faces. E mais três botões: para o sinal de mais, o de menos e o de igual.

Ao apertar um dos dados ele saberá que quero jogar com ele. Ele esperará eu apertar no sinal de igual para a operação randômica executar. Os sinais servem para aumentar ou diminuir o que resultar do dado. Cada vez que eu apertar num deles incrementa-se ou descrementa-se em um.

Logicamente vou escrever esse aplicativo em Python. Vamos ver se tenho a sorte e produtividade de terminá-lo ainda neste final de semana. Quando concluir, posto por aqui.

Da prática para a especulação

Especulam se haverá aumento da compra de imóveis ao longo dos próximos anos. Vamos citar exemplos práticos. Sei de várias pessoas próximas a mim que estão planejando comprar um imóvel (casa ou apartamento), neste ano ou no próximo ano. E grande parte deles não é sequer o foco do badalado Minha Casa, Minha Vida.

O problema em Teresina, não sei em outros lugares, é o aumento do preço dos imóveis. Uma parte considera os preços propostos muito irreal. Resta saber se nos meses que se seguem ou mesmo em 2010 os preços começam a baixar.

Socialismo fracassou, capitalismo quebrou: o que vem a seguir?

Esse artigo eu encontrei no site do Paulo Henrique Amorim, o Conversa Afiada. Comenta um assunto que eu já venho lendo e notando em diversos lugares da Internet. É uma nova forma de ver o mercado e o rumo da política.

A prova de uma política progressista não é privada, mas sim pública. A prioridade não é o aumento do lucro e do consumo, mas sim a ampliação das oportunidades e, como diz Amartya Sen, das capacidades de todos por meio da ação coletiva. Isso significa iniciativa pública não baseada na busca de lucro. Decisões públicas dirigidas a melhorias sociais coletivas com as quais todos sairiam ganhando. Esta é a base de uma política progressista, não a maximização do crescimento econômico e da riqueza pessoal. A análise é do historiador britânico Eric Hobsbawm

Eric Hobsbawm – The Guardian Seja qual for o logotipo ideológico que adotemos, o deslocamento do mercado livre para a ação pública deve ser maior do que os políticos imaginam. O século XX já ficou para trás, mas ainda não aprendemos a viver no século XXI, ou ao menos pensá-lo de um modo apropriado. Não deveria ser tão difícil como parece, dado que a idéia básica que dominou a economia e a política no século passado desapareceu, claramente, pelo sumidouro da história. O que tínhamos era um modo de pensar as modernas economias industriais – em realidade todas as economias -, em termos de dois opostos mutuamente excludentes: capitalismo ou socialismo.

Conhecemos duas tentativas práticas de realizar ambos sistemas em sua forma pura: por um lado, as economias de planificação estatal, centralizadas, de tipo soviético; por outro, a economia capitalista de livre mercado isenta de qualquer restrição e controle. As primeiras vieram abaixo na década de 1980, e com elas os sistemas políticos comunistas europeus; a segunda está se decompondo diante de nossos olhos na maior crise do capitalismo global desde a década de 1930. Em alguns aspectos, é uma crise de maior envergadura do que aquela, na medida em que a globalização da economia não estava então tão desenvolvida como hoje e a economia planificada da União Soviética não foi afetada. Não conhecemos a gravidade e a duração da atual crise, mas sem dúvida ela vai marcar o final do tipo de capitalismo de livre mercado iniciado com Margareth Thatcher e Ronald Reagan.

A impotência, por conseguinte, ameaça tanto os que acreditam em um capitalismo de mercado, puro e desestatizado, uma espécie de anarquismo burguês, quanto os que crêem em um socialismo planificado e descontaminado da busca por lucros. Ambos estão quebrados. O futuro, como o presente e o passado, pertence às economias mistas nas quais o público e o privado estejam mutuamente vinculados de uma ou outra maneira. Mas como? Este é o problema que está colocado diante de nós hoje, em particular para a gente de esquerda.

Ninguém pensa seriamente em regressar aos sistemas socialistas de tipo soviético, não só por suas deficiências políticas, mas também pela crescente indolência e ineficiência de suas economias, ainda que isso não deva nos levar a subestimar seus impressionantes êxitos sociais e educacionais. Por outro lado, até a implosão do mercado livre global no ano passado, inclusive os partidos social-democratas e moderados de esquerda dos países do capitalismo do Norte e da Australásia estavam comprometidos mais e mais com o êxito do capitalismo de livre mercado.

Efetivamente, desde o momento da queda da URSS até hoje não recordo nenhum partido ou líder que denunciasse o capitalismo como algo inaceitável. E nenhum esteve tão ligado a sua sorte como o New Labour, o novo trabalhismo britânico. Em suas políticas econômicas, tanto Tony Blair como Gordon Brown (este até outubro de 2008) podiam ser qualificados sem nenhum exagero como Thatchers com calças. O mesmo se aplica ao Partido Democrata, nos Estados Unidos.

A idéia básica do novo trabalhismo, desde 1950, era que o socialismo era desnecessário e que se podia confiar no sistema capitalista para fazer florescer e gerar mais riqueza do que em qualquer outro sistema. Tudo o que os socialistas tinham que fazer era garantir uma distribuição eqüitativa. Mas, desde 1970, o acelerado crescimento da globalização dificultou e atingiu fatalmente a base tradicional do Partido Trabalhista britânico e, em realidade, as políticas de ajudas e apoios de qualquer partido social democrata. Muitas pessoas, na década de 1980, consideraram que se o barco do trabalhismo não queria ir a pique, o que era uma possibilidade real, tinha que ser objeto de uma atualização.

Mas não foi. Sob o impacto do que considerou a revitalização econômica thatcherista, o New Labour, a partir de 1997, engoliu inteira a ideologia, ou melhor, a teologia, do fundamentalismo do mercado livre global. O Reino Unido desregulamentou seus mercados, vendeu suas indústrias a quem pagou mais, deixou de fabricar produtos para a exportação (ao contrário do que fizeram Alemanha, França e Suíça) e apostou todo seu dinheiro em sua conversão a centro mundial dos serviços financeiros, tornando-se também um paraíso de bilionários lavadores de dinheiro. Assim, o impacto atual da crise mundial sobre a libra e a economia britânica será provavelmente o mais catastrófico de todas as economias ocidentais e o com a recuperação mais difícil também.

É possível afirmar que tudo isso já são águas passadas. Que somos livres para regressar à economia mista e que a velha caixa de ferramentas trabalhista está aí a nossa disposição – inclusive a nacionalização -, de modo que tudo o que precisamos fazer é utilizar de novo essas ferramentas que o New Labour nunca deixou de usar. No entanto, essa idéia sugere que sabemos o que fazer com as ferramentas. Mas não é assim.

Por um lado, não sabemos como superar a crise atual. Não há ninguém, nem os governos, nem os bancos centrais, nem as instituições financeiras mundiais que saiba o que fazer: todos estão como um cego que tenta sair do labirinto tateando as paredes com todo tipo de bastões na esperança de encontrar o caminho da saída.

Por outro lado, subestimamos o persistente grau de dependência dos governos e dos responsáveis pelas políticas às receitas do livre mercado, que tanto prazer lhes proporcionaram durante décadas. Por acaso se livraram do pressuposto básico de que a empresa privada voltada ao lucro é sempre o melhor e mais eficaz meio de fazer as coisas? Ou de que a organização e a contabilidade empresariais deveriam ser os modelos inclusive da função pública, da educação e da pesquisa? Ou de que o crescente abismo entre os bilionários e o resto da população não é tão importante, uma vez que todos os demais – exceto uma minoria de pobres – estejam um pouquinho melhor? Ou de que o que um país necessita, em qualquer caso, é um máximo de crescimento econômico e de competitividade comercial? Não creio que tenham superado tudo isso.

No entanto, uma política progressista requer algo mais que uma ruptura um pouco maior com os pressupostos econômicos e morais dos últimos 30 anos. Requer um regresso à convicção de que o crescimento econômico e a abundância que comporta são um meio, não um fim. Os fins são os efeitos que têm sobre as vidas, as possibilidades vitais e as expectativas das pessoas.

Tomemos o caso de Londres. É evidente que importa a todos nós que a economia de Londres floresça. Mas a prova de fogo da enorme riqueza gerada em algumas partes da capital não é que tenha contribuído com 20 ou 30% do PIB britânico, mas sim como afetou a vida de milhões de pessoas que ali vivem e trabalham. A que tipo de vida têm direito? Podem se permitir a viver ali? Se não podem, não é nenhuma compensação que Londres seja um paraíso dos muito ricos. Podem conseguir empregos remunerados decentemente ou qualquer tipo de emprego? Se não podem, de que serve jactar-se de ter restaurantes de três estrelas Michelin, com alguns chefs convertidos eles mesmos em estrelas. Podem levar seus filhos à escola? A falta de escolas adequadas não é compensada pelo fato de que as universidades de Londres podem montar uma equipe de futebol com seus professores ganhadores de prêmios Nobel.

A prova de uma política progressista não é privada, mas sim pública. Não importa só o aumento do lucro e do consumo dos particulares, mas sim a ampliação das oportunidades e, como diz Amartya Sen, das capacidades de todos por meio da ação coletiva. Mas isso significa – ou deveria significar – iniciativa pública não baseada na busca de lucro, sequer para redistribuir a acumulação privada. Decisões públicas dirigidas a conseguir melhorias sociais coletivas com as quais todos sairiam ganhando. Esta é a base de uma política progressista, não a maximização do crescimento econômico e da riqueza pessoal.

Em nenhum âmbito isso será mais importante do que na luta contra o maior problema com que nos enfrentamos neste século: a crise do meio ambiente. Seja qual for o logotipo ideológico que adotemos, significará um deslocamento de grande alcance, do livre mercado para a ação pública, uma mudança maior do que a proposta pelo governo britânico. E, levando em conta a gravidade da crise econômica, deveria ser um deslocamento rápido. O tempo não está do nosso lado.

Artigo publicado originalmente no jornal The Guardian.

Tradução do inglês para o espanhol: S. Segui, integrante dos coletivos Tlaxcala, Rebelión e Cubadebate.

Tradução do espanhol para o português: Katarina Peixoto