funmachine


Deixe um comentário

Node.js 101: Error Handling

“Why handle errors?”

Because as a programmer, catching errors is part of your job. You need to know when a disk write fails, a database query times out, or a web service returns zero bytes. You need to be able to react to exceptional (and not-so-exceptional) conditions, and do The Right Thing, even if The Right Thing is merely to print out that error and exit.

Node.js 101: Error Handling | Doug’s Home On The Web.


Deixe um comentário

Python + VirtualEnv

Tenho trabalhado ultimamente com a framework web Django e um dos maiores problemas com que tenho lidado ocorre quando por algum motivo preciso correr a framework noutro ambiente, por exemplo noutro PC. Ao contrário do desenvolvimento PHP, onde tipicamente temos uma stack estanque com todos os módulos PHP necessários, em Python e particularmente em Django, as coisas são um pouco diferentes. A verdade é que à medida que vamos desenvolvendo vamos também instalando uma série de módulos e dependências que depois precisamos de replicar se quisermos correr o ambiente de desenvolvimento sem problema. Mas nesse processo vários inconvenientes podem acontecer, caso a versão do Python usada originalmente para o projeto seja diferente da que temos instalada na máquina de destino, ou se alguns módulos tiverem também versões diferentes. Poderíamos simplesmente atualizar a versão do Python e dos módulos necessários para a que o nosso projeto utiliza, mas aí os outros projetos podem deixar de funcionar! Se, pelo contrário, deixarmos as versões que temos no sistema, então aí pode o projeto que queremos migrar não correr!

Claro que já muita gente se deparou com uma situação destas, e a solução para gerir este inferno de versões e dependências é utilizar Virtual Environments. A ideia é muito simples: utilizamos um software que cria virtual envs na nosso máquina é nos permite alternar entre eles. Enquanto estivermos com um virtual env activado, todos os módulos Python instalados ficam associados a esse virtual env. Simples!

Vamos então aprender mais um pouco sobre um dos softwares que podemos utilizar para criar Virtual Environments em Python, chamado (naturalmente) VirtualEnv.

Para instalar o VirtualEnv podem usar a ferramenta easy_install:

$ easy_install virtualenv

Depois de instalado com sucesso, podem criar um ambiente virtual com o seguinte comando:

$ virtualenv my_venv

Com este comando é criado um ambiente virtual já com as packages base Python, ou seja, todas as global site-packages Python que tinham instalado anteriormente são herdadas, incluindo o próprio Python!

Caso queiram criar um VirtualEnv “vazio” usem o comando:

$ virtualenv  –no-site-packages my_venv

Isto pode ser útil para, por exemplo, criar um VirtualEnv com uma versão diferente Python da global.

Depois de criado o VirtualEnv, podemos ativá-lo usando o comando:

$ source my-venv/bin/activate

Desta forma, estamos a trabalhar neste VirtualEnv. Qualquer tarefa Python que usem vai usar este VirtualEnv. Notem como aparece o nome do VirtualEnv na consola.

Agora queremos instalar uma package Python neste VirtualEnv. Para isso, com o VirtualEnv activado, simplesmente usamos o easy_install (ou outra ferramenta de instalação de packages Python):

$(my_venv) easy_install yolk

A assim o yolk é instalado no VirtualEnv “my_venv”.

Quando quisermos sair de um VirtualEnv, simplesmente usamos o comando:

$(my_venv) deactivate

Simples, não? Uma pequena nota: o yolk, entre outras coisas, serve para sabermos quais os packages Python que temos instalados. Se correrem o comando:

$(my_venv) yolk -l

são listadas todas as packages e suas versões que atualmente estão instaladas no ambiente virtual ativo, neste caso “my_venv”. Se nenhum ambiente virtual estiver ativo então são listadas as packages globais.

Ok, temos o nosso trabalho simplificado, podemos criar VirtualEnv facilmente, e se depois quisermos correr um projeto noutro ambiente de desenvolvimento, basta recriar o VirtualEnv. Além disso, há outra tarefa que fica simplificada – testar novas versões de packages! Basta criar um virtualenv novo e instalar as novas versões e verificar como o nosso programa funciona com as novas versões. A qualquer momento podemos voltar ao ambiente estável, bastando trocar de VirtualEnv.

Mas este processo de gerir as dependências do nosso projeto ainda não é perfeito! Recriar VirtualEnvs dá trabalho, temos que saber quais as packages instaladas e voltar a instalar tudo de novo! O yolk facilita o trabalho, mas ainda assim acho que precisa ser mais automático! A solução é simples também: vamos criar um script Python que trata de instalar por nós as dependências!

Criem um ficheiro Python com este código:

import virtualenv, textwrap
output = virtualenv.create_bootstrap_script(textwrap.dedent("""
def after_install(options, home_dir):
    subprocess.call([join(home_dir, 'bin', 'easy_install'),
                    'yolk'])
"""))
print output

Gravem o ficheiro, por exemplo, como main.py

No terminal, corram:

$ python main.py > install-venv.py

E depois corram o ficheiro Python resultante com o nome do VirtualEnv que querem recriar como parâmetro:

$ python install-venv.py my_venv

Et voilá! Este script trata de criar o VirtualEnv my_venv, com todas packages que quisermos instalar! (neste exemplo apenas yolk)


Deixe um comentário

Hello Node

Depois de muito ouvir falar da framework Node.js, resolvi experimentar instalar e correr um “Hello Node”. Para quem não sabe, Node.js é um ambiente javascript que corre do lado do servidor e usa um modelo assíncrono baseado em eventos. O que isto quer dizer é que o Node suporta concorrência, mas de uma forma simples para o programador, em contraste com o modelo de threads, que além de ineficiente, provoca algumas dores de cabeça, principalmente no acesso a recursos. O Node resolve isto de maneira simples, porque no fundo, os processos não correm em paralelo, o que acontece é que o Node assenta naquilo que sempre foi o core do javascript: o Event Loop. O Event Loop é a maneira como o javascript lida com pedidos que podem surgir de qualquer parte do programa. No Node o modelo de programação é totalmente baseado em eventos, assim sendo, fazer um programa Node passa por indicar uma série de eventos que podem acontecer, e definir as callbacks que tratam destes eventos. Isto é parecido com o javascript no browser, que espera interacção dos utilizadores, mas neste caso, como estamos do lado do servidor, temos uma nova gama de eventos que dependem do software que estamos a correr no nosso servidor. Um exemplo é o módulo HTTP, que tem o evento “request”, este é emitido quando um cliente faz um pedido ao servidor.

Penso que o buzz à volta do Node assenta muito nestes conceitos, primeiro usa javascript, uma linguagem fácil e bem conhecida e adoptada em ambiente web. Em segundo lugar é eficiente, e tem um modelo de programação simples, fácil de entender e de gerir, principalmente no que toca ao modelo de concorrência. Claro que o Node tem outras tantas vantagens, principalmente penso que tem muito a dizer no que toca a aplicações web colaborativas, que me parecem ter uns requisitos que encaixam como uma luva neste ambiente, no entanto, só o tempo o dirá, e à medida que for explorando mais o Node, com certeza irei formar e trazer opiniões mais concretas.

Existe muito mais para falar sobre o Node, os recursos encontram-se maioritariamente na web, visto que ainda não existe nenhum livro sobre Node. No entanto a O’reilly já se prepara para lançar um livro “animal” sobre Node, podem aceder à preview aqui.

Nada melhor para perceber e ficar motivado com Node do que fazer um pequeno “Hello Node”. Vou então demonstrar como podem instalar e executar programas Node localmente na vossa máquina. Dificilmente irão encontrar serviços de hosting com suporte a Node, no entanto existem já alguns projectos interessantes que oferecem alojamento Node de borla, muito útil principalmente para fazer uns testes. Um desses serviços, que descobri por acaso, é o Nodester. Uma outra opção que têm se quiserem colocar os vossos programas Node online é usar um serviço cloud, por exemplo o AWS da amazon. Noutro post irei demonstrar como podemos instalar e executar programas Node numa VM da amazon, mas para já, fiquemos por uma instalação local.

O primeiro comentário, e espero que não faço já desistir muita gente, é que precisamos de uma ambiente UNIX para correr o Node. Isto quer dizer que quem tiver Windows tem que instalar uma VM se quiser experimentar e continuar tutorial. Eu testei com Ubuntu, mas penso que para o pessoal dos Macs, tudo é igual.

Existe formas de instalar em ambiente Windows, mas, na minha opinião, ainda são um pouco instáveis, de qualquer forma, podem dar uma olhadela aqui.

1 – Primeiro temos que fazer download do Node. Apontem o browser para a página de downloads do Node.js e façam download do Node.js. (alternativamente podem fazer um check do repositório git)

2 – Abram a shell e extraiam o tar.gz.

3 – Façam cd para dentro na directoria Node.

4 – A seguir devem fazer configure:

$ sudo ./configure

5 – Depois make (aqui é a altura que podem começar a ler a preview do livro Node,js 😉 )

$ sudo make

6 – Finalmente make install:

$ sudo make install

Durante este processo, é possível que sejam identificadas dependências em falta nas vossas máquinas. Esta são bem identificadas, uma pesquisa na net e nos repositórios Ubuntu permitem facilmente instalar estas dependências.

Finalmente, um passo que não é obrigatório, mas que no futuro pode dar muito jeito:

Instalar o NPM, este é o package manager usado para instalar e gerir extensões e módulos Node.

$ curl http://npmjs.org/install.sh | sudo sh

Um exemplo é express.js, uma framework web development para Node. Quando quiserem instalar um módulo (exemplo: express.js) novo basta fazer:

$sudo npm install express

Se tudo correu bem, temos o Node,js instalado no nosso sistema. Finalmente vamos fazer um exemplo e ver a “coisa” a correr!

Abram o vosso editor de código preferido e escrevam o seguinte código js:

var http = require('http');
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/plain'});
res.end('Hello World\n');
}).listen(8080);
console.log('Server running at http://localhost:8080');

Não vou tentar explicar muito este Hello World, mas quem tiver alguma experiência em javascript com certeza percebe o que se está aqui a passar:

require(‘http’); // factory que retorna um objecto http

de seguida invoca-se o método createServer, que cria um servidor Http. Este recebe uma função com dois parâmetro , req e res.

req é o evento,  quando o server receber um evento request

res é a callback associado ao evento req.

Quando um evento é emitido, por exemplo, um pedido do browser, res escreve um header (writeHead) e depois com .end escreve a mensagem “Hello World”.

Por fim está associado .listen(8080), para indicar que está a “escutar” o porto 8080.

Para correr este exemplo, guardem o ficheiro como example.js e corram no terminal:

$ sudo node example.js

De seguida, apontem o browser para “http://localhost:8080” et voilá!

Fácil, não?

Uma nota, num estilo à la python, o Node vem como uma consola interactiva que permite testar e executar código Node.

Para a usar basta digitar: $ node na consola e podem começar a escrever e executar código javascript e Node.