A duas semana eu escrevi um blogpost sobre “Trabalhar para empresa de fora do Brasil” e realmente vale muito apena, como a demando do projeto aumentou consideravelmente estamos precisando de desenvolvedores para entrar no time. Nosso time é responsável por desenvolver algumas ferramentas de SEO.

Conhecimento necessario:

• Dominio do idioma inglês;
• Python;
• Django (Caso conheça outro frameworks é importante).

Itens importante:

• Tradução de projeto open source;
• Foco (Como o trabalho é remoto, temos que sempre ter foco no que estamos fazendo);
• Conhecimento em arquitetura de software;
• Contribuido com projeto open source (Ideal que tenho o repositorio aberto);
• Ótimo conhecimento em desenvolvimento ágil;

Estamos procurando por pessoas criativas, que gostem de inovação, de pesquisar e identificar novas tendências e de encarar desafios complexos com agilidade e velocidade.

Se você se encaixa neste perfil, envie seu curriculo em inglês para mim (thiagoavelinoster AT gmail.com) com uma lista dos últimos 5 livros técnicos que você leu, Github, Twitter, LinkedIn e o que você quiser compartilhar.

Hoje fecha um total de 3 dias trabalhando na empresa Mochii (Realmente achei o site da empresa muito nerd e extremamente diferente, esse e outros motivo me fez trabalhar com eles) e durante esses três dias tive uma ótima experiencia para compartilhar.

Primeiro que o dono da empresa é muito acessível, sem essa frescura de hierarquia (Não que eu ache totalmente hierarquia desnecessário, mas em alguns caso ao meu ver não precisaria de tanta burocracia).

Segundo que o time de desenvolvimento de lá é 100% aberto a ideias e a criticas (logicamente que criticas construtivas e que saiba conversa sobre o porque não concorda com determinada parte do código), muito diferente de alguns desenvolvedores no Brasil (Sei que tem em outros lugares do mundo mas como trabalhei muito tempo no Brasil estou usando como referencia) que se apega com código desenvolvido.

Uma coisa que realmente me deixou muito surpreso foi em relação a cobrança de como esta indo a tarefa que eu (Thiago Avelino) assumi, o dono da empresa chegou para mim e falou que eu deveria conversa com um funcionario que saberia explicar melhor sobre o porque esta usando a tecnologia X, Y e Z, depois do lider do desenvolvimento me explicado foi atribuido uma tarefa e não fui cobrado nem uma vez sobre a tarefa, realmente isso é muito diferente aqui no Brasil, principalmente quando um desenvolvedor novo entra em um time, geralmente tem sempre um cara no time que fica pergunta “e ai esta entendendo?“, ao meu ver isso tem o seu lado bom e consequentemente o seu lado ruim.
O lado bom é que tem a interação do time com o novo desenvolvedor, mais isso acaba ficando chato pois se o novo desenvolvedor não esta entendo ele vai ficar com vergonha (ou alguma coisa do genero) de se expressa falando que não esta entendo alguma parte do fluxo do projeto ou mesmo código.

Poderia falar mais 1001 experiência que tive essa semana, mas vou ir gerando blog post com os passar das semanas, assim posso ir aprofundando cada dia mais da experiência vivida.

Realmente vale apena trabalhar para uma empresa de fora do Brasil.

Ultimamente estou estudando bastante Javascript para colocar algumas aplicações em Node.js no ar, ate que tive a minha primeira necessidade real de usar Nodejs.

Na Nodegrid tivemos a necessidade fazer grande processamento assíncrono, temos um servidor de cache que foi desenvolvimento por necessidade de armazenamento e controle do que esta em cache e tempo para expirar o mesmo, poderia ser usado memcache mas a Nodegrid esta fazendo um serviço de hosting de memcache, com isso teríamos o problema de concorrência de nome dentro do banco chave e valor (Memcache).

No case que tenho com a Nodegrid na solução de cache (Djazz.cache) começamos a desenvolver usando ‘C’, funcionou muito bem, mas com o passar do tempo a manutenção do software começou ficar trabalhosa. Eu tenho experiencias com software grande em C (Kernel BSD) e mesmo assim a manutenção de um software não é nada confortável. Migrei para Python com Twisted, mais infelizmente o códigos usando Twisted não fica muito agradável ou seja não é Pythônico então olhei para o projeto Node.js que tem a característica simples e facil de trabalhar com processamento assíncrono.

Recomendo olhar o trabalho que os commiters do Node.js estão fazendo, tem muitas ideias ótimas e outra que precisa ser melhoradas.

Vejo a Node.js como uma solução ótima e simples para trabalhar com conexões assíncrono, ainda hoje não vejo o Node.js substituindo uma linguagem que já esta a anos rodando em backend como Python, Ruby, Java e etc. Ao meu ver o Node.js vai crescer ainda mais o seu uso nas necessidades específica (assíncronas), pela simplicidade de implementação e fácil manutenção.

Link o slide da palestra “Node.js em produção“

Tem muitas pessoas que acha que escrever teste não garante que o software não tem bug, isso é claro, mas vamos encarar o problema quando quando tiver que mudar o software, caso ele esteja como teste na parte onde esta sendo implementado novas funcionalidade e venha quebrar ai sim vamos dar valor aos teste.

Uns dos tópicos da minha palestra é como acostumar a escrever teste, geralmente não é um trabalho muito simples, quando começamos a praticar técnicas de desenvolvimento de software como TDD é um trabalho muito chato pois não temos experiencia e nem costume de escrever um teste para depois implementar o software passar na quela teste, vendo este cenário podemos chegar a conclusão que muitos desenvolvedores não sabe realmente o que precisa ser desenvolvido e com isso fica ainda mais complicado de praticar TDD.

Antes de desenvolvermos um software a primeira coisa é saber o que o software vai fazer, só assim a pratica de TDD começa e ficar mais fácil e fluente, uma dica que dou para quem começa da implementa camada de teste unitário em um projeto é participar de Coding Dojo e de PythonStorm (Ideia do nosso amigo Rodolpho Eckhardt) onde é reunido um grupo para fazer para bater um papo sobre tecnologia (Python) e falar sobre melhores praticas.

Esse é referente aos primeiros slides da palestra, vou escrever as próximos slides no próximos webposts.

Link dos slides da palestra: http://www.slideshare.net/avelinoo/test-para-os-fracos

Com o VIM podemos ter todos os recurso avançado que temos em qual quer IDE, basta algumas configurações para que esses recursos ser ativado, para facilitar a vida de todos compartilhei o meu .vimrc e nesse post vou explicar como usar o mesmo.

"Em 2 de novembro de 1991, Bram Moolenaar publicava a primeira versão do edito vim. O vim nasceu como um clone para Amiga do editor vi criado por Bill Joy em 1976, adicionando algumas funcionalidades extras, daí seu nome (VI iMproved ou VI Melhorado). Este editor se adaptou rapidamente a outras plataformas. "

Assumindo que o vi já esta instalado no meu micro, vamos instalar as configurações que eu fiz, basta rodar os seguintes comando no seu bash (Linux ou Mac):

curl https://raw.github.com/avelino/.vimrc/master/bootstrap.sh -o - | sh

Após isso ele vai baixar o repositório na sua pasta HOME.
Recomendo o uso o VIM em GUI pois podemos chegar 256 cores, ou seja, colocar temas mais agradável e assim deixando o uso do vim mais confortável para o desenvolvimento, para Linux é o gvim e para mac o macvim (Para mac o Björn Winckler fez um ótimo trabalho, na minha humilde opinião é a melhor versão do VIM via GUI).

Chega de blablabla né, vamos logo para o que realmente interessa, como o VIM ficou e como utilizar ele?

Usando o vim para navegar nas pasta de um projeto:

Buscando arquivo por nome dentro do projeto:

Listar todas as class e def do arquivo esta esta aberto (Python)

Lista de comandos para usar no ‘vim’, lembrando que esses comando foi customizado:

• :cd /path Abrir pasta
• tn Abrir nova aba
• te Abrir nova aba e carregar arquivo
• t] Proxima aba
• t[ Voltar aba
• Ctrl+c Adicionar todos os arquivos no cache para poder fazer busca de arquivo (recomendo fazer isso ao abrir o projeto)
• Ctrl+f Busca arquivo e abre na mesma aba
• Ctrl+s Busca arquivo e abre em uma nova aba
• \b Abre arquivo que esta no buffer do vim (Arquivo abertos)
• \d, \n ou F3 Abre navegador de arquivo
• \f Lista todas as class e def (Python)
• \j Vai para declaração de um metodo
• \r Renomear todos os metodos
• [e Move linha para cima
• e] Move linha para baixo
• \v ouCtrl+w + v` Divide a tela em vertical
• \h ou Ctrl+w + s Divide a tela em horizontal
• \w ou Ctrl+w + q Fecha a aba atual
• Ctrl+k Abre console Python
• Ctrl+j Roda o script Python aberto
• \sh Abre bash (shell)
• \p Manda o arquivo em aberto para o dpaste.com
• \ga Git add .
• \gc Git commit
• \gsh Git push
• \gs Git status
• \gd Git diff
• \gr Git remove
• \S Remove todos os espaços do final
• \c Lista controle de versao do buffer

Para você atualizar o seu Nexus S faça o seguinte procedimento:

• 1 – Faça download da imagem do Android 4.0 para o Nexus S no seguinte link:
  http://android.clients.google.com/packages/ota/google_crespo/VQ8PQk_V.zip ou http://dl.dropbox.com/u/763381/VQ8PQk_V.zip
• 2 – Coloque o VQ8PQk_V.zip SD do seu Nexus S e você deve renomear o arquivo para update.zip
• 3 – Desligue o seu aparelho
• 4 – Aperte o botão do volume para cima + o botão power, seu celular vai iniciar no modulo fastboot
• 5 – Selecione a opção recovery
• 6 – Vai começa carregar e aparecera um triângulo com um !, nessa tela você deve aperta o botão power + volume para cima (Deve ser na sequência relatado no post)
• 7 – Vai aparecer um menu onde você deve selecionar a seguinte opção Apply update from /sdcard
• 8 – Após instalar você deve selecionar reboot system now
• 9 – Pronto, Android 4.0.3 instalado no seu Nexus S

Quando o seu celular for ligar a primeira vez com Android 4.0 ele vai ficar um pouco lento pois vai refazer o dalvik cache.

Lembrando que você tem que ter a versão do Android oficial do Google instalado no seu Nexus S, caso não esteja não vai conseguir fazer os procedimentos, pois estamos atualizando para a versão oficial do Google.

O Google vai liberar aos poucos a atualização automatica para os Nexus S pois se não vai acabar com o link das operadoras, no Brasil principalmente que nosso 3G é um 2G.

• Suporte para aplicações web
• Suporte para criação de pasta (Na versão 0.1 da API não tinha)
• Novo site para desenvolvedores, com documentação simples e completa https://www.dropbox.com/developers_beta
• Melhor compartilhamento de arquivo, streaming, busca por arquivo e suporte para revisão de arquivo
• Implementação no controle de nomes de arquivos, para não sobrescrever arquivos já salvo
• SDK atualizado para iOS, Android, Python, Ruby e Java que implementa todas modificações e documentação

Link do repositorio (Python Pypi) da nova biblioteca http://pypi.python.org/pypi/dropbox/1.1

O dropbox implementou um oauth onde podemos desenvolver software e fazer o usuário usar a conta de dropbox dele para armazenamento de arquivos:

Vou falar um pouco sobre 3 metodos que esta dentro da biblioteca “dropbox” client, rest e session:

Com o metodo session é por onde tudo começa, onde você linka o seu software com uma conta Dropbox, exemplo:

# Include the Dropbox SDK libraries
from dropbox import session

# Get your app key and secret from the Dropbox developer website
APP_KEY = 'INSERT_APP_KEY_HERE'
APP_SECRET = 'INSERT_SECRET_HERE'

# ACCESS_TYPE should be 'dropbox' or 'app_folder' as configured for your app
ACCESS_TYPE = 'INSERT_ACCESS_TYPE_HERE'
sess = session.DropboxSession(APP_KEY, APP_SECRET, ACCESS_TYPE)

Caso esteja usando a conta do Dropbox do usuário podemos pegar informações da conta dele:

client = client.DropboxClient(sess)
print "linked account:", client.account_info()

Agora usando o metodo “client” podemos fazer get e put de arquivos:

from dropbox import client
f = open('working-draft.txt')
response = client.put_file('/magnum-opus.txt', f)
print "uploaded:", response

Após criar o arquivos podemos ler ele:

print client.get_file('/magnum-opus.txt').read()

Reescrever o arquivo com uma nova revisão para criar um novo arquivo:

out = open('magnum-opus.txt', 'w')
out.write(client.get_file('/magnum-opus.txt',rev='362e2029684fe').read())

Para trabalhar com REST temos um ótima documentação https://www.dropbox.com/developers_beta/reference/api

A solução que cheguei foi, criar uma lib chamada “_md5″, criei um arquivo chamado “_md5py”:

class _md5:
    def __init__():
        import md5
        return md5

Lendo as documentação vi que a lib “hashlib._md5″ foi deprecada pois a md5 ficou no lugar. Espero que ajude outras pessoas que esta com esse problema.

QUnit é um Framework open source de teste unitário para JavaScript. Ele foi desenvolvido para fazer teste unitários no desenvolvimento do próprio Jquery, mas é capaz de testar qualquer código Javascript (Até mesmo testar código Javascript do lado do servidor NodeJS).

Segue abaixo o exemplo de uma implementação simples:

<html>
<head>
  <script src="http://code.jquery.com/jquery-latest.js"></script>
  <link rel="stylesheet" href="http://code.jquery.com/qunit/git/qunit.css" type="text/css" media="screen" />
  <script type="text/javascript" src="http://code.jquery.com/qunit/git/qunit.js"></script>
  <script>
    function calc(val1, val2, oper){
      val1 = typeof val1 == 'undefined' ? 0 : val1
      val2 = typeof val2 == 'undefined' ? 0 : val2
      oper = typeof oper == 'undefined' ? "+" : oper

      if(oper == "+")
        cal = val1 + val2
      else if(oper == "-")
        cal = val1 - val2
      else
        cal = false

      return cal
    }
  </script>

  <script>
    $(document).ready(function(){

      module("Test render html")
      test("test valor in #test1", function(){
        equals("ok ok ok", $("#test1").html())
        notEqual("ok ok ok ", $("#test1").html())
      })

      module("Test function calc()")
      test("test basic return 10", function(){
        equals(10, calc(10))
        notEqual(10, calc(11))
      })

      test("test basic sum 2 parameter", function(){
        equals(20, calc(10, 10))
        notEqual(21, calc(10, 10))
        deepEqual(20, calc(10, 10))
        notStrictEqual("20", calc(10, 10))
      })

      test("set operator +", function(){
        equals(20, calc(10, 10, "+"))
        equals(false, calc(10, 10, "..."))
      })

      test("set operator -", function(){
        equals(1, calc(10, 9, "-"))
      })

    })
  </script>

</head>
<body>
  <h1 id="qunit-header">QUnit example</h1>
  <h2 id="qunit-banner"></h2>
  <div id="qunit-testrunner-toolbar"></div>
  <h2 id="qunit-userAgent"></h2>
  <ol id="qunit-tests"></ol>
  <div id="qunit-fixture">test markup, will be hidden</div>

  <div id="test1">ok ok ok</div>
</body>
</html>

No código acima estou fazendo dois tipos de testes: um módulo de item renderizado na página, e outro módulo de teste de uma função de cálculo.

Segue abaixo o print de como ficou o test:

Em Python temos a biblioteca HamlPy ela pega os files HAML e gera o HTML para usarmos em nossos sistemas.

Vamos logo para a pratica, chega de lero lero.

%html{'xmlns':"http://www.w3.org/1999/xhtml", 'lang':"en", "xml:lang":"en"}
  %head

    %title Testando Haml

    %style{'type': 'text/css'}
      body{font-family: verdana;}

    %script{'type':'text/javascript', 'src':'https://www.google.com/jsapi?key=ABQIAAAAUgaJsDgRTDbR5vvhnJ3iYBT2yXp_ZAY8_ufC3CFXhHIE1NvwkxS2j2XMXVpjyqg8A7TkHl2W04abvA'}
    %script{'type': 'text/javascript'}
      google.load("jquery", "1.6.1");

  %body
    #header
      %h1#lero
        .test Haml
        %ul.navigation
          - for run in varloop
            %li= run
    #content
      Testando para ver se funciona o HamlPy

Esse é um layout feito com haml, é muito simples pois não precisamos ficar fechando as tags, assim os erros de html é 100% resolvido, como converte o haml para html:

/Users/avelino/.virtualenvs/haml/bin/hamlpy template/index.haml template/index.html

O binario hamlpy recebe dois parâmetros o primeiro é o input file haml o segunda é o output a saída html, depois de rodarmos o hamlpy temos uma saida da seguinte forma:

<html lang='en' xmlns='http://www.w3.org/1999/xhtml' xml:lang='en'>
  <head>
    <title>Testando Haml</title>
    <style type='text/css'>
      body{font-family: verdana;}
    </style>
    <script src='https://www.google.com/jsapi?key=ABQIAAAAUgaJsDgRTDbR5vvhnJ3iYBT2yXp_ZAY8_ufC3CFXhHIE1NvwkxS2j2XMXVpjyqg8A7TkHl2W04abvA' type='text/javascript'></script>
    <script type='text/javascript'>
      google.load("jquery", "1.6.1");
    </script>
  </head>
  <body>
    <div id='header'>
      <h1 id='lero'>
        <div class='test'>Haml</div>
        <ul class='navigation'>
          {% for run in varloop %}
            <li>{{ run }}</li>
          {% endfor %}
        </ul>
      </h1>
    </div>
    <div id='content'>
      Testando para ver se funciona o HamlPy
    </div>
  </body>
</html>

Minha views do Django declaro sempre com o arquivo .html que foi gerado com o hamlpy. Veja como ficou o meu views:

# -*- coding: utf-8 -*-
"""
    views

    :copyright: (c) 2011 by the Avelino Labs, see Thiago Avelino <thiago@avelino.us> for more details.
    :license: BSD, see LICENSE for more details.
"""

from django.shortcuts import render_to_response
from django.template import RequestContext

def index(request):
    return render_to_response(
            'index.html',
            context_instance=RequestContext(request))