PEX: Empacotando projetos python e suas dependências em um único arquivo

Fri, 13 Oct 2017 00:00:00 +0000

Antes de começar a falar do PEX é importante conhecer um comportamento pouco explorado do interpretador do Python. Para isso vamos criar um arquivo de exemplo com o seguinte conteúdo e chamá-lo de teste.py:

print("Tudo ok! Hello World!")

O código pode ser executado com o comando python teste.py. Mas para o nosso exemplo tentaremos executá-lo assim:

~/Code/me/pex $ python .

Mas receberemos um erro que diz que não existe um módulo “main” no diretório atual, o que é verdade já que nosso único o arquivo se chama teste.py.

/Users/raelmax/.pyenv/versions/2.7.13/bin/python: can't find '__main__' module in '.'

Nesse momento você já deve ter percebido qual é o tal comportamento pouco explorado. Se mudarmos o nome do nosso arquivo de teste.py para __main__.py ao executarmos o comando python . o arquivo __main__.py será executado, exemplo:

~/Code/me/pex $ mv teste.py __main__.py
~/Code/me/pex $ python .
Tudo ok! Hello World!

Indo um pouco além podemos “zipar” esse arquivo __main__.py e o comportamento do interpretador não muda:

~/Code/me/pex $ zip teste.zip __main__.py
  adding: __main__.py (stored 0%)
~/Code/me/pex $ python teste.zip
Tudo ok! Hello World!

Podemos também criar um diretório contendo nosso arquivo __main__.py e executá-lo da mesma forma:

~/Code/me/pex $ mkdir teste
~/Code/me/pex $ mv __main__.py teste/
~/Code/me/pex $ python teste
Tudo ok! Hello World!

Esses comportamentos são padrões do interpretador do python, foram melhorados com a PEP 441 e o PEX usa para criar ambientes python independentes, que é o nosso objetivo.

O que é o PEX

O PEX é o responsável por gerar arquivos independentes que contém um ambiente python completo, como um virtualenv. Ao gerar um arquivo PEX ele cuida dos detalhes necessários para criar um arquivo “zip” que atenda aos padrões do interpretador do python, adicionando um arquivo __main__.py e o header #!/usr/bin/env python.

A documentação do projeto é bem completa e dá mais detalhes sobre como tudo funciona, você pode conferir aqui: https://pex.readthedocs.io/.

Instalando o PEX

A instalação é feita usando o pip, como qualquer outro pacote python:

~/Code/me/pex $ pip install pex

Eu encontrei um pequeno probleminha nessa abordagem de instalação porque ela requer que você tenha um virtualenv ativo ou permissão para instalar como um pacote global. Para conseguir fugir desses dois pontos eu fiz um pequeno script que baixa, instala no /tmp/ e cria um executável PEX usando o próprio PEX:

~/Code/me/pex $ curl -L https://bit.ly/pex-standalone | bash

Caso você tenha usado a primeira abordagem você terá disponível o comando pex, se você optou por usar o meu script você precisará executar com ./pex. Nas dicas a seguir eu usarei o arquivo gerado pelo meu script.

Ambientes virtuais temporários

Com o PEX instalado podemos criar ambientes virtuais tanto temporários quanto permanentes. Para exemplificar vamos criar um ambiente virtual com a biblioteca requests:

~/Code/me/pex $ ./pex -v requests
  urllib3 1.22pex :: Resolving distributions
  requests 2.18.4
  certifi 2017.7.27.1
  chardet 3.0.4
  idna 2.6
pex: Building pex: 1249.6ms
pex:   Resolving distributions: 1243.7ms
Running PEX file at /var/folders/lp/bl8845jd6td_f_f99jfm034r0000gn/T/tmpQvgSXG with args []
pex: PEX.run invoking /Users/raelmax/.pyenv/versions/2.7.13/bin/python2.7 /var/folders/lp/bl8845jd6td_f_f99jfm034r0000gn/T/tmpQvgSXG
Python 2.7.13 (default, Oct 10 2017, 14:59:59)
[GCC 4.2.1 Compatible Apple LLVM 9.0.0 (clang-900.0.37)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)
>>> import requests
>>> r = requests.get('https://raelmax.github.io/')
>>> r.status_code
200

Com esse comando o PEX executa o interpretador do python com o pacote especificado no PYTHONPATH, o que pode ser bem útil no momento do desenvolvimento. Caso o pacote que você queria instalar possua um executável você pode usar a flag -c para dizer para o PEX executá-lo. Vamos usar o thumbor nesse exemplo:

~/Code/me/pex $ ./pex thumbor -c thumbor -- --version
Thumbor v6.3.2 (10-Apr-2017)

O -- é usado para dizer para o PEX que os próximo parâmetros serão passados para o programa que você está executando(no caso, o thumbor) e não para o próprio PEX.

Salvando ambientes PEX

Apesar de ser útil durante o desenvolvimento, os ambientes temporários não são tão interessantes quando você costumar usar sempre os mesmos softwares, nesse caso é interessante persistir o seu ambiente. Para esse exemplo vamos usar o httpie:

~/Code/me/pex $ ./pex httpie -c http -o httpie.pex
~/Code/me/pex $ ./httpie.pex --version
0.9.9
~/Code/me/pex $ ./httpie.pex --print h https://raelmax.github.io
HTTP/1.1 200 OK
Accept-Ranges: bytes
Access-Control-Allow-Origin: *
Age: 0
Cache-Control: max-age=600
Connection: keep-alive
Content-Encoding: gzip
Content-Length: 3055
Content-Type: text/html; charset=utf-8
Date: Sat, 14 Oct 2017 14:15:29 GMT
Expires: Sat, 14 Oct 2017 14:11:09 GMT
Last-Modified: Thu, 22 Sep 2016 22:55:15 GMT
Server: GitHub.com
Vary: Accept-Encoding
Via: 1.1 varnish
X-Cache: MISS
X-Cache-Hits: 0
X-Fastly-Request-ID: ce8dfb821c7e25940ebd20819c14f602f828558d
X-GitHub-Request-Id: BC2E:18C4E:826E725:BD29B8D:59E218A4
X-Served-By: cache-gru17128-GRU
X-Timer: S1507990529.067934,VS0,VE142

Conclusão

O PEX é uma ótima alternativa para quem quer testar um novo pacote sem “sujar” o ambiente de desenvolvimento do seu projeto e também para quem usa projetos python que contém scripts no dia a dia, como o thumbor, httpie e outros. Nesse segundo caso a grande vantagem é não precisar ter um virtualenv apenas para esses projetos e ter que ficar alternando entre o virtualenv do projeto e o virtualenv que contém esses scripts, nem mesmo “sujar” sua instalação global do Python.

Uma última dica é criar um diretório para abrigar todos esses executáveis e colocar no seu PATH, com isso você não precisará chamar o executável com o PATH completo e poderá fazer isso de dentro do seu projeto mesmo. Para isso eu criei um diretório ~/.pybin e coloquei lá o arquivo pex gerado pelo meu script e sempre que crio um executável novo também mando pra lá. E adicionei esse diretório ao meu .bash_profile:

~/Code/me/pex $ echo 'export PATH="~/.pybin:$PATH"' > ~/.bash_profile

É isso! :)

Livro: O último teorema de Fermat

Thu, 22 Sep 2016 00:00:00 +0000

Há uns meses vi uns colegas de trabalho falando sobre a história de Fermat, um matemático que viveu no século XVII e que tinha como principal diversão resolver e criar problemas relacionados a lógica e a teoria dos números. Fiquei tão curioso pela história que resolvi procurar o livro e encontrei numa ótima promoção da Amazon, pagando apenas 13 reais pelo livro físico.

O livro é uma aula sobre a história da matemática usando como ponto central os esforços de estudiosos de vários tempos para conseguir uma demonstração para esse teorema, deixado como uma anotação de canto de livro por Pierre de Fermat alguns anos antes de sua morte e que só foi resolvido quase quatro séculos depois, tendo “derrotado” vários dos mais importantes matemáticos da história.

A leitura é bem tranquila e não é restrita apenas a pessoas com conhecimento matemático, já que os fatos são mostrados em uma linguagem muito clara e não se apega a detalhes de cálculo. Um outro ponto interessante é a forma que o autor traz uma minibiografia de todos os gênios que tentaram demonstrar o teorema e explica de forma clara qual a contribuição que cada um deixou para seus sucessores, o que me deixou bem curioso pra saber como a história terminaria.

Esse livro é uma ótima fonte para quem se interessa por matemática e também para aqueles que gostam de uma boa história. Mas não vá por mim, pois eu sou um mentiroso.

Domínios customizados no Heroku com PointDNS

Thu, 15 Sep 2016 00:00:00 +0000

Há tempos uso o heroku para testar algumas ideias mas nunca havia chegado ao ponto de apontar um domínio relevante pra lá, até hoje.

Bom, o heroku permite que você coloque um domínio próprio(~~desde que deixe seu cartão de crédito lá~~), mesmo no plano gratuito, o problema é que como o apontamento só pode ser feito para o domínio do app no heroku(algo como app-exemplo.herokuapp.com), não temos como fazer apontamentos que não sejam do tipo CNAME. Para termos mais flexibilidade nas configurações de DNS o heroku oferece alguns addons, entre eles o PointDNS, que no plano gratuito oferece a possibilidade de várias configurações para um domínio. Então vamos lá configurar.

Adicionando o PointDNS ao projeto

O primeiro passo para configurar o serviço de DNS é vincular o PointDNS ao projeto. Isso pode ser feito tanto pela página do addon no heroku quanto pela linha de comando, usando o heroku toolbelt:

$ heroku addons:create pointdns:developer -a nome_do_app
Creating pointdns:developer on ⬢ nome_do_app...

Feito isso você pode adicionar um domínio customizado pelo dashboard ou pela linha de comando:

$ heroku domains:add dominio-exemplo.com -a nome_do_app
$ heroku domains:add *.dominio-exemplo.com -a nome-do-app

Para abrir o painel do PointDNS você pode seguir usando a linha de comando:

$ heroku addons:open pointdns

O painel abrirá no seu browser padrão. Na aba “Nameservers” você pode encontrar uma lista de endereços de DNS que você pode usar para fazer o apontamento do domínio(no painel da godaddy, registro.br, etc).

A partir daí você pode ir na aba “Domains” e selecionar o seu domínio criado nos passo anteriores, podendo criar registros de redirect , CNAME, A e fazer configurações mais complexas.

Bom, é isso. Até onde deu pra ver as únicas limitações do PointDNS na versão gratuita é a quantidade de domínios(apenas 1) e a quantidade de registros(no máximo 10) e resolve bem o problema que se propõe.

Abraço!

6 meses no Rio de Janeiro

Sun, 31 Jan 2016 00:00:00 +0000

Há tempos planejava me mudar para uma cidade maior e entre as cidades brasileiras o Rio de Janeiro sempre esteve em primeiro lugar na minha lista de possibilidades. Convencer a Jerssica de que essa seria uma boa decisão não foi nada fácil e não aconteceu da noite pro dia, mas depois de alguns meses de muita conversa - e de vários “e se” - chegamos a um consenso e decidimos que esse seria o melhor “próximo passo” que poderíamos dar na nossa vida.

Processo seletivo

Logo que tomamos a decisão entrei no processo seletivo para uma vaga no time de plataformas da Globo.com. O processo é separado em algumas fases. No início tive uma entrevista por telefone com o gestor da área, após um longo papo(~1h) fui convidado a fazer um desafio de programação, topei de imediato.

Alguns dias depois de enviar o código do desafio, entraram em contato comigo me convidando a ir até a sede da empresa e participar de mais uma fase do processo. Nessa fase eu passaria o dia dentro da empresa interagindo com um ou dois times para me avaliarem. Algum tempo depois dessa visita à empresa recebi uma proposta e decidi aceitar, em mais ou menos um mês eu embarcava de Imperatriz para o Rio.

Cittá América / Globo.com

A mudança

Sem dúvidas essa foi a parte mais chata de todas. Como forma de facilitar a contratação de pessoas de outras partes do país, a Globo.com ajuda na mudança dos funcionários contratados. Até aí beleza, mas eu precisava me livrar de muita coisa que não poderia trazer(em Imperatriz a rede é 220v e aqui no Rio é 110, tchau eletrônicos), entregar a casa que eu morava, embalar caixas, desmontar móveis, etc. Uma tarefa e tanto pra ser feita em um mês mas tinha que dar.

E deu. Entreguei a casa 2 dias antes da viagem e ficaram poucos detalhes que a Jerssica ficou de resolver antes de vir pra cá com o Bruce. Aliás, esse foi outro “problema”, mas conseguimos resolver. Apesar de encher muito o saco durante o vôo conseguimos trazer o Bruce sem problemas. Aliás, se o Bruce não pudesse vir ninguém viria, né.

Então há exatos 6 meses peguei o vôo para o Rio. Uma coisa chata que tivemos que lidar é que como passei o primeiro mês inteiro procurando apartamento para alugar e morando num hotel, tivemos que ficar separados, a Jerssica e o Bruce lá em Imperatriz e eu aqui. Mas já passou, ainda bem. :)

Achar um lugar pra morar foi um desafio. A Globo.com fica na Barra da Tijuca, que é um bairro bem caro e bem distante da parte mais famosa da cidade, logo, morar longe não era uma boa opção mas morar perto também não sairia barato. Depois de visitar váaaarios apartamentos nas redondezas e aqui na Barra achei um apartamento bacana com um custo aceitável e de certa forma bem perto do trabalho. Com o apartamento alugado pude receber meus negros maravilhosos e começar mais uma fase da jornada, a adaptação.

O Bruce parece que gostou da nova vista. :)

A vida no Rio

De certo modo acredito que tenhamos subestimado essa mudança. Começar uma nova vida do zero nunca vai ser algo fácil. No fim das contas a gente deixou todo o conforto que tínhamos da nossa casa, família e amigos por um monte de incertezas. Mas mesmo com tudo isso acreditamos que esteja valendo a pena.

Comparar Imperatriz com o Rio não faz sentido, são cidades bem diferentes, com estilos diferentes e funções diferentes. E foi com essa cabeça que cheguei aqui e foi justamente isso que deixou tudo mais fácil.

Fomos no Maracanã ver o Barcelona da Gávea

Mas nem tudo são flores e tem algumas coisas que me incomodam por aqui. O custo de vida é um negócio maluco, e aqui na Barra é pior ainda, a sensação que se tem é de que você está o tempo todo dentro de um aeroporto. A distancia entre os lugares também é bem chato, até os lugares que teoricamente são perto no fim das contas são bem longe. No geral as pessoas parecem estar boladas o tempo inteiro e pelo menos comigo tem sido raro dar um obrigado e ouvir um de nada.

Algumas coisas me surpreenderam de forma positiva. O transporte público apesar de ser uma bosta é muito bom dependendo de onde você veio. Eu não estava acostumado a poder ir tão longe gastando tão pouco. Outra coisa é a violência que apesar de ser algo bem presente não é tão ruim quanto se vê no jornal.

No mais, ainda estamos acostumando com a cidade e com as pessoas. Ainda nos assustamos ao entrar no supermercado e ver um senhorzinho de sunga, ou em perceber que dois(ou três) corpos podem sim ocupar o mesmo espaço como acontece nos ônibus. Ou que o pouco aqui ainda é muito, o perto ainda é muito longe, o barato ainda é bem caro e coisas do tipo. São detalhes que a gente vai aprendendo com o tempo, mas que não chegam a ser um problema.

A cidade é maravilhosa, mas se liga.

Metas para 2015

Fri, 02 Jan 2015 00:00:00 +0000

Resolvi anotar aqui uma lista de coisas que tentarei alcançar nesse ano que se inicia, espero cumprir boa parte! :)

andar mais de bike;
comer melhor, dia vegan/vegetariano é uma boa;
levar testes automatizados mais a sério;
concluir a série bottle e quem sabe lançar um site em pt-br com todos os textos;
colocar meus projetos pessoais atrasados no ar;
manter a casa limpa e organizada;
me mudar, de casa ou de cidade(de preferência);
blogar mais;
viajar, pra perto ou pra longe, por muito ou por pouco tempo.

Acho que é isso, vamos ver até onde vai!

Bottle: começando na web com python

Wed, 03 Dec 2014 00:00:00 +0000

Se você já tem uma experiência mais avançada em desenvolvimento web e/ou python, recomendo ler o tutorial oficial do Bottle, aqui o ritmo será bem mais lento pois o foco são os iniciantes!

Trabalho com web há alguns anos, passei rapidamente por PHP e logo em seguida comecei a trabalhar com python e por consequência com Django. O início foi bem doloroso, não sei se todos tem a mesma impressão, mas acredito que python(para a web) tem uma curva de aprendizado muito grande se comparado ao PHP(que ainda é a grande porta de entrada da web), são muitas coisas a aprender para colocar um simples projeto em python no ar enquanto em PHP tudo que se precisa fazer é “escrever um arquivinho e jogar no ftp”.

Pensando nisso resolvi escrever uma série de artigos para ajudar iniciantes em desenvolvimento web a darem os primeiros passos utilizando python. Vamos lá?

Requisitos

Saber o básico de python (import, funções, tipos de dados…)
Conhecer um pouco de html será bastante útil também
Um computador com linux(pra facilitar as coisas pra mim. :)

Configurando o ambiente

Assumindo que você esteja usando Linux e que o Python já vem por padrão na maioria das distribuições, vamos configurar nosso ambiente para depois partirmos para as explicações.

Primeiro, crie um diretório na sua home com o nome “meu_projeto” e em seguida baixe o arquivo bottle.py para esse diretório. Caso queria fazer isso no terminal execute:

1
mkdir meu_projeto && cd meu_projeto && wget https://raw.githubusercontent.com/bottlepy/bottle/master/bottle.py

Com isso você já estará pronto para desenvolver seu projeto em python, utilizando o Bottle. Mais na frente aprenderemos a isolar nosso ambiente de desenvolvimento, gerir dependências e muito mais, por hora isso é mais que o suficiente.

Hello World

Com o Bottle “instalado” no passo anterior, vamos agora escrever nossa primeira aplicação web, será um exemplo clássico de “Hello World!”. Para isso, crie um arquivo “app.py” no diretório “meu_projeto”.

Abra o arquivo com seu editor de código preferido e digite o seguinte:

1
2
3
4
5
6
7
from bottle import route, run

@route('/')
def index():
    return 'Hello World!'

run(host='localhost', port=8080)

Nesse pequeno trecho de código temos uma aplicação web básica. Na primeira linha temos os “imports”. No python, quando precisamos buscar coisas(variáveis, funções, classes…) que estão em outros arquivos usamos essa sintaxe. Como no passo anterior fizemos download de um arquivo “bottle.py” que se encontra no mesmo diretório do nosso arquivo “app.py”, podemos importar funções do módulo bottle[.py]. Nesse caso importamos as funções “route” e “run”.

Na linha 3 temos a definição da “rota”. Podemos chamar de rotas todos os endereços acessíveis da sua aplicação web, como “/” que é a raíz ou “/contato” que seria sua página de contato. Para definir uma rota no Bottle usamos a função “route”, que importamos na primeira linha. Essa função é usada como um decorator nas funções que representam uma página da sua aplicação, o conceito de decorator é um pouco complexo e podemos deixar para depois, o importante é você entender qual o papel do “route”. Note que o decorator “route” recebe um parâmetro, nesse caso “/”, que significa que estamos mapeando a rota da url raíz da aplicação. Resumindo: o “route(“/”)” faz com que ao acessar a url raíz o Bottle invoque a função que está abaixo do “route”, no caso, a função “index”.

Na linha 4 temos a definição da função “index” que é a função usada para responder à url raíz da nossa aplicação. O nome “index” poderia ser trocado por qualquer outro, pois o que define a qual rota responderá essa função é o decorator “route” que está logo acima da definição dela.

Na linha 5 temos o retorno da função “index”. Nesse caso estamos retornando uma string com o nosso “Hello World”. Essa é fácil, né. :)

Na última linha usamos o comando “run”(importado na primeira linha) para dizer ao python “hey, executa esse código aqui!” e nele passamos dois parâmetros, o “host” que seria a url da aplicação e “port”, que será a porta usada para rodar a aplicação.

Simples, não? :)

Executando a aplicação

O último passo dessa etapa é rodar nossa aplicação, para isso execute no terminal:

1
cd meu_projeto && python app.py

Agora, acesse no seu navegador o endereço: http://localhost:8080 e veja o seu primeiro app em python rodando! \o/

Concluindo

Esse é um exemplo básico de como desenvolver uma aplicação simples, nesse primeiro artigo abordamos alguns princípios que fazem parte de qualquer aplicação web em Bottle e nos demais daremos uma incrementada nesse projeto.

Dúvidas, críticas e sugestões nos comentários! :)

Links úteis

Não somos tão bons assim

Tue, 25 Nov 2014 00:00:00 +0000

Há alguns meses precisei desenvolver uma aplicação para um dispositivo da motorola que roda Windows CE 5. Conversei com um amigo que já tinha experiência com esses dispositivos e ele me falou que havia uma versão do python e do tk que rodava perfeitamente, logo optei por desenvolver dessa forma. Era perfeito, trabalho com python há bastante tempo e resolveria o problema rapidamente.

Aplicação desenvolvida e testada, encomendamos mais dispositivos e após meses de espera fui colocar a aplicação para rodar, aí começou o problema. Os novos dispositivos vieram atualizados com Windows CE 6.0 e o python só rodava até a versão 5.x. Todo o trabalho foi por água a baixo.

Pesquisei alternativas e aí tive que desenvolver a aplicação utilizando C#, no .Net Compact Framework e DB4O para o banco de dados. Tentamos fazer a implantação por duas vezes e falhamos. Não deu erro, não tinha bugs(até tinha, mas não veio ao caso) e tudo havia sido implementado do “jeito certo”. Então qual o problema? Bom, entendíamos bastante de tecnologia, conversamos bastante sobre o problema que o cliente precisava resolver, mas não entendíamos como as coisas funcionavam no dia-a-dia da empresa, e isso fez com que todo o trabalho fosse em vão e com quem precisássemos reescrever a aplicação com base na experiência que tivemos nas tentativas anteriores.

Com isso aprendi algumas coisas que são interessantes de serem apontadas, acredito que pelo menos uma vez você já tenha passado por algo parecido.

Nem tudo é o que parece

Essa foi minha primeira experiência com um aplicativo desktop, trabalho com web há muito tempo e achei que não poderia ser tão diferente. Nunca me enganei tanto. Os problemas são diferentes, suportar 10mil req/s não é a mesma coisa que 10mil pessoas numa loja, por exemplo.

Se você não é especialista no assunto, não suponha, teste

Em alguns casos achei que uma requisição pela rede wifi demoraria demais e no fim das contas se mostrou mais rápido que fazer a leitura em disco(sério). Errei em não estudar a fundo o dispositivo usado e tivemos vários problemas desse tipo.

Conheça bem os pontos de falha

O dispositivo é específico para coleta de dados(leitura de código de barras) e em vários casos a leitura demorou mais do que a checagem(no banco). Isso não passou pela minha cabeça em momento algum, afinal, o dispositivo é feito para isso, e como é de se imaginar, não nos preparamos para esse problema.

Ambiente de implantação

Numa aplicação desktop, onde praticamente toda a infraestrutura é local, é importantíssimo que se conheça muito bem os possíveis problemas. Essa foi a maior das falhas. Quando trabalhamos com web, é muito fácil reproduzir o ambiente dos usuários do sistema, há inúmeras ferramentas e geralmente ter várias versões dos principais browsers já cobre 90% dos casos. No caso dessa aplicação local, fazer suposições e testes com o que imaginávamos do cenário da implantanção foi longe de ser uma boa ideia.

Converse com quem entende

Mesmo conhecendo profissionais que já fizeram esse tipo de projeto, não nos preocupamos em perguntar mais sobre como funciona, quais os problemas comuns ou quais as melhores abordagens. Poderíamos ter poupado muito tempo e esforço se tivéssemos nos atentado para isso.

Dá pra resumir tudo isso em excesso de confiança e inexperiência. Agora é recolher os cacos e transformar tudo isso em experiência, até porque no fim das contas não somos tão bons assim.

PythonBrasil[9]: Dicas de frontend para projetos django

Sun, 24 Nov 2013 13:37:14 +0000

Nos dias 2, 3 e 4 de outubro tive a oportunidade de mais uma vez participar da PythonBrasil, dessa vez pude contribuir um pouco mais com a comunidade apresentando uma palestra no último dia de evento.

O tema que abordei foi frontend em projetos django, visto que esse é um assunto muito importante dentro do desenvolvimento de aplicações web e que também tem sido a área que mais tenho trabalhado nos últimos dois anos.

O vídeo da palestra está disponível aqui:

E os slides:

Bom, é isso aí!

Aquele primeiro post que todo mundo faz

Sun, 24 Nov 2013 13:37:14 +0000

Olá, amigos.

Como é de praxe, precisava escrever alguma coisa aqui para não deixar aquele post default, né. O que também serve para dar uma enganada e até faz você pensar que isso aqui será atualizado com frequência. E talvez seja.

Vou tentar compartilhar aqui alguns frutos da experiência que tenho adquirido sobre desenvolvimento de software nos últimos anos.

Para me ajudar nisso, escolhi o Ghost como plataforma. Sabe como é, nada mais cool do que um blog em node.js. Bom, é isso aí, nos vemos num post de verdade. :)