funmachine


Deixe um comentário

Backbone.js monitoring with Caliper.io

Here is a great tool for Backbone.js app’s monitoring

via Quick review: Backbone.js monitoring with Caliper.io | Raymond Julin.

Anúncios


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

An Open Web

Esta força toda que tem surgido em torno do movimento Open Web tem pouco a ver com uma perspetiva puramente técnica de desenvolvimento com tecnologia Web – HTML5 e JS e CSS, etc. É muito mais que isso. Para quem desenvolve para a web no dia a dia, percebe facilmente que ainda estamos muito longe de ter tecnologia completamente agnóstica que corre em qualquer dispositivo de forma nativa. Podemos correr web apps em qualquer browser, que por sua vez existem em qualquer SO, mas ainda estamos muito longe de ter uma integração ideal a nível dos recursos do SO.

Quem tentar criar uma aplicação puramente baseada em tecnologia Web, mas que possa correr, por exemplo, num ambiente desktop, percebe bem a questão….. Não existe forma fácil de, por exemplo, criar uma aplicação chromeless, sem fazer uso dos UIs do browser. Correr em modo Fullscreen não é solução e muito menos correr em frameworks como PhoneGap, que apenas permitem correr uma aplicação web dentro de um rudimentar widget web, com muitas limitações ao nível das funcionalidades suportadas, para não falar na limitação de performance.

Além disso, mais restritivo que desenvolver uma aplicação chromeless é desenvolver uma que faça uso dos recursos do sistema operativo, e apesar de haver grande progressos nessa área (FileSystem API, Local Storage API, etc) ainda estamos longe de ter acesso aos recursos que, por exemplo, as SDK windows, mac, android, iOS nos permitem.

Para mim, frameworks como PhoneGap são uma faca de dois legumes, como o grande treinador dizia… Por um lado prometem desenvolvimento rápido e cross-platform, o que é verdade. Mas por outro, correm a app web em cima de um widget rudimentar, que é disponibilizado pelas SDKs do iOS, do Android, etc., como uma simples view para criar interfaces web simples. Depois os developers passam o seu tempo a tentar otimizar a performance da app…

Por outro lado temos os browsers. Autêntica artilharia pesada. Conseguem alta performance, mas é muito difícil sair do contexto browser, ou seja, é difícil implementar uma aplicação chromeless. É possível integrar apenas os seus layout e render engines? Sim, podemos usar o Gecko, WebKit, etc e embeber num software nosso, mas não é tarefa fácil. Existe um projecto chamado CEF que não é mais que uma API para embeber o Chromium em virtualmente qualquer aplicação. Depois existe uma série de projetos para embeber o Gecko, o motor do Firefox, mas que infelizmente, são sempre abandonados… Por fim existe um projeto chamado Awesomium que é uma framework que permite tirar partido do browser (Chromium/WebKit) para criar aplicações windowless, mas sendo algo comercial e fechado, acabamos sempre sem saber bem em que versão do browser nos podemos basear, nunca temos a certeza que funcionalidades suportam no futuro nem quanto tempo demoram a integrar as evoluções do WebKit (se é que o fazem).

Agora, temos o renascer do gigante. A Mozilla, que tem grande responsabilidade pela web tal como a conhecemos, voltou em força e está atualmente a puxar novamente as fronteiras da web!

A Mozilla está em força com a iniciativa Open Web. Ao longo dos últimos tempos têm tentado estender os web standards para incluir uma série de APIs necessárias para desenvolver aplicações em sistemas móveis que realmente fazem uso nativo do SO. Vejam aqui uma compilação das APIs que estão a ser desenvolvidas.

O primeiro é o projecto Boot To Gecko – B2G , onde estão a desenvolver um sistema operativo mobile baseado no projeto Gecko e que tem como principal novidade as aplicações nativas em aplicações HTML5/JS. Desta forma podemos desenvolver aplicações usando tecnologia HTML5 e JS e ter acesso a um conjunto de recursos do sistema operativo, ou seja, a Mozilla quer tornar a Open Web como uma plataforma para um sistema mobile.

Depois temos a iniciativa Open Web Apps. A Mozilla finalmente vai lançar o seu Web Apps Marketplace, um local onde podemos encontrar, comprar e fazer download de aplicações Web. Um pouco semelhante ao Google Web Apps, mas com a inovação e “passo à frente” que tem sido a bandeira da Mozilla. O funcionamento é muito semelhante às Web Apps Chrome. Temos um MarketPlace onde podemos distribuir  e gerir aplicações Web. O passo à frente nesta iniciativa é o WebRT – Web Run Time:

“Desktop WebRT is a project to build a desktop web application runtime that provides webapps with a native-like look and feel along with platform integration APIs on Windows, Mac, and other desktop platforms.”

A ideia é que ao instalar a Web App existe uma funcionalidade do Firefox que instala a aplicação no sistema operativo nativo e depois podemos correr a aplicação nativamente. Esta ao ser executada corre como se fosse no Firefox, mas num ambiente chromeless.

Estou ansioso por verificar como está plataforma vai desenvolver ao longo do tempo, à muito que ando à procura de uma forma de desenvolver aplicação desktop usando tecnologias Web, principalmente na parte das UIs, com todo o poder dos browsers modernos actuais, e a iniciativa Open Web da Mozilla, particularmente o projecto B2G e WebRT prometem isso mesmo!


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)