Vou relatar um caso desses, em que criar algo novo foi necessário. Pra começar imagine uma aplicação web qualquer dessas que se utilizam de facebook/twitter connect. Você se loga com sua conta de um desses serviços pra adiantar bons passos de cadastro, evitar criar mais um senha, etc, caso do Agendatech por exemplo.

Agora imagine um ação digital que ocorreu principalmente no Orkut e fez com que alguns milhões de usuários interagissem com a marca. Você tem a opção de uma nova campanha inciando toda viralização novamente ou continuar com rodos esses usuários já ativados.

O problema aqui é que claramente o Orkut não oferece recursos de desenvolvimento tão avançados, e é sobre essa experiencia que quero descrever nesse post. Antes, queria lembrar a todos que, em tempos modernos que todos querem fazer aplicativos pra facebook/twitter, bons programadores querem resolver problemas de software.

Ei Orkut, me autoriza.
Eu nunca tinha visto nenhuma aplicação web que tenha um Orkut conect até então. E esse é o primeiro problema.
Muito desenvolvimento já foi feito prao Orkut na forma de aplicativos, aqueles que rodam dentro dá própria rede social,mas não me recordo e não encontrei nenhum que utilizasse na forma off-site.

Muitos dos links do Google nesse sentido estão quebrados ou desatualizados, encontrar alguma coisa em Ruby então, muito difícil.

Qualquer biblioteca de connect hoje utiliza OAuth. O processo todo costuma se encapsulado em alguma biblioteca pra facilitar as coisas.
Existe uma lib do Orkut chamada Orkut OS Client, escrita em Java. Após testar essa lib, da pra ver que ela consegue fazer o connect e acessar dados de perfil do Orkut, além de scraps e outras coisas.

Atravessando a ponte
Uma primeira solução aqui poderia ser um serviço intermediário. Esse serviço precisaria ser acessado pela app Rails, faria o connect utilizando a lib java e devolveria o resultado da requisição. Nada impossível de se fazerm utilizando Sinatra e JRuby, acessados via REST. Essa solução tem pontos positivos, como utilizar a própria lib do Google pra fazer as coisas, mas subir um serviço a mais gera mais possíveis pontos de falha, como tratamento mensagens entre os servers, falha no serviço, etc.

Portando
Se a lib Java faz, então da pra fazer em Ruby. A primeira idéia que vem na cabeça aqui normalmente é: “Abre lá a lib Java, ve as URL’s que ela chama e faz todos os parsers você mesmo em Ruby”.

Seria órimo se fosse assim. A lib Java utiliza uma forma bem peculiar pra prover as informações. Não temos aqui um webservices preparadinho pra atender e responder nossas necessidades.
O Orkut oferece as informações via RPC-JSON. Esse não é de longe o formato de comunicação mais da moda, mas é o que tem.
Basicamente esse formato espera apenas posts, mesmo que pra solicitar informações. Esses posts deve ser feitos pra um RPC Endpoint com uma mensagem formatada, adivinhe em que, JSON. Claro que essa mensagem deve seguir as convenções e parametros que o serviço entenda.
O retorno é outro JSON com a resposta da requisição.

Mas eu to na moda
Minha primeira opção pra resolver esse problema de connect e authorização pelo orkut em um sistema Rails, foi utilizar o Omniauth.
O Omniauth é uma gem bem reconhecida pra isso no meio Ruby e permite que você crie sua própria estratégia caso um provider nnao esteja pronto.
Fiz isso e criei a estratégia para o Orkut.
Um belo passo frente ao problema, agora era capaz de pedir ao orkut a conexão, autorizar o usuário, e receber um token de acesso.
Precisamos de um token pois qualquer solicitação ao serviço vai precisar dessa validação.

Aparentemente uma primeira etapa concluída, agora só falta consumir os dados como perfil e scraps. Porém aqui tudo vai por água abaixo.
O Orkut não aceita utilizar um token gerado por outras formas pra pedir os dados no serviço RPC-JSON. Ele responde com falha na autenticação e bloqueia tudo. Voltamos a estaca zero.

Faça-se a luz
Voltar pra solução do serviço intermediário utilizando a própria lib java do Orkut é uma opção. Mas pelos problemas citados acima vale mais um estudo. Conhecendo um pouco mais do processo interno da lib Java, e entendendo como é feito todo processo de requissição e autenticação, resolvi portar a lib pra uma versão Ruby. Essa alternativa tem o problema de ser um pouco mais trabalhosa e precisar de conhecimento de Ruby e Java,
e refazer processos como o de autenticação por captcha com oauth autorizado, entre outras partes,
porém elimina os problemas de ter um serviço a mais só pra executar essa tareefa. Tendo uma lib Ruby pra fazer tanto o connect quanto oas requisições pra serviços temos tudo na mesma linguagem e ambiente, faciltando muito as coisas.

A bliblioteca em questão foi chamada de orkut_os_client, tem um demo online e o código está no Github.
Tenho muitas dúvidas de como melhorá-la ou como testa, ou seja, se você estiver a fim de dar uma olhada, não exite em conversar comigo.

Essa biblioteca já passou por diversas requisições, e o código é utilizado em um sistema com um número pesado de acessos por minuto, ou seja, vem cumprindo bem sua função

Conclusão
O Phillip Calçado fez um post muito legal sobre a importância do conhecimento de tecnologias antigas, sua evolução, etc.
Se você é um programador, o problema a ser resolvido deveria ser aquilo que te motiva. Conhecimento de tecnologias antigas ajuda muito na criação de tecnologias novas.

Amanhã teremos muito mais conteúdo interessante, divididos entre Ruby, Agile e Arquitetura. A track de Ruby que tenho a honra de apresentar amanhã foi escolhida com muito cuidado, com palestrantes e temas bem atuais, focando em problemas e soluções, algumas antigas outras mais novas.

Palestrantes

Nelson Haraguchi será o primeiro a falar, apresentando problemas e soluções em projetos Ruby com 80 milhões de requisições na Boo-Box. Como suportar um crescimento tão grande e escalar sistemas desse porte.

Muitos projetos Ruby hoje são desenvolvidos por programadores com experiencia em Java, ou mesmo possuem ambas as linguagens, utilizando o melhor dos mundos. Toda essa história pode ser aproveitada para utilizando o melhor das ferramentas disponíveis. Hiro Asari, JRuby engineer da Engine Yard vai falar sobre essa convergência e como anda o projeto JRuby atualmente.

Pegando mais um gancho no assunto, muitas lições aprendidas por programadores experientes em outras linguagens tem sido esquecidas em projetos Ruby. Vinicius baggio, mais um integrante do GURU-SP vai mostrar técnicas que não podem ser esquecidas por novos programadores.

Após essa toda essa trajetória, chegamos a ferramentas da atualidade que buscam resolver mais desses problemas. Bruno Alves, da Dito, vem contar casos reais de uma aplicação Ruby escalável através de Node.js, Redis e Rails.

Pra fechar e cada vez mais abrirmos as possibilidades atuais na internet, Shay Frendt, da Think Relevance, conhecida empresa principalmente por conta do Clojure, fala sobre a utilização de Ruby e Rails em projetos para iOS como iPad e iPhone.

Esperamos vocês lá!

Existem alguns sites que tentavam fazer isso, mas todos muito desatualizados ou que não tinham uma proximidade grande com as comunidades de tecnologia, o que fazia com que esses sites apenas mostraassem eventos grandes, que todos já conhecem.

O Agendatech é populado por uma série de programadores, desenvolvedores, designers, empreendedores, arquitetos e diversos outros profissionais de tecnologia, fazendo com que eventos pequenos ou grandes possam ser localizados.

Desde o surgimento uma série de pessoas já colaboraram com o projeto, que é desenvolvido em Rails e roda no Heroku. Agradecimentos especiais ao Vini Baggio, um dos maiores commiters do projeto desde que ele surgiu. Para conferir a lista de colaboradores clique aqui.

O agendatech teve apoio de muitos eventos, e fica aqui os agradecimentos especiais a Caelum, InfoQ e RubyInside.

Novidades

Algumas das novidades que colocamos no ar foi o novo layout e o upgrade para Rails 3.

Além disso agora é possível fazer um login rápido com seu twitter e clicar no botão “EU VOU”, que agrupa todos os participantes.

Na área de descrição do evento temos agora possibilidade de discussão sobre temas do evento.

Versão Android

Ainda não temos a melhor app para Android mas demos o passo inicial. Já está disponível na Android Market a aplicação que permite listar e cadastrar eventos via JSON.

Falta um bom design além de diversas melhorias, mas assim como começamos a versão web, a versão mobile para Android também está disponível open-source no github.

Fica os agradecimentos ao Jonas Alves e Daniel Passos, pelos commits e refatorações dessa primeira versão.

Se você tiver idéias ou gostaria de ajudar com novas funcionalidades, testes automatizados ou refactoring não deixe de mandar seu pull request!

The Blog-Health-o-Meter™ reads This blog is on fire!.

Crunchy numbers

A Boeing 747-400 passenger jet can hold 416 passengers. This blog was viewed about 10,000 times in 2010. That’s about 24 full 747s.

In 2010, there were 12 new posts, growing the total archive of this blog to 41 posts. There were 67 pictures uploaded, taking up a total of 3mb. That’s about 1 pictures per week.

The busiest day of the year was September 12th with 204 views. The most popular post that day was Rails 3 Internals.

Where did they come from?

The top referring sites in 2010 were blog.caelum.com.br, andersonleite.com.br, davidpaniz.com, twitter.com, and google.com.br.

Some visitors came searching, mostly for jquery shadow, anderson leite, restfulie, shadow jquery, and clojure.

Attractions in 2010

These are the posts and pages that got the most views in 2010.

Rails 3 Internals September 2010
4 comments

#1 Metaprogramação: Ruby Object Model February 2010
10 comments

JQuery | Reflection e Shadow November 2009

Sobre February 2009

#2 Metaprogramação: Definindo métodos February 2010
8 comments

Máquina / Sistema Operacional
Uso Mac OS X desde 2006. Até 2009 usei um Macbook White 13″ e hoje um Macbook Pro 13″. Em casa uso um monitor adicional de 22″. Gosto de mouse, claro que não pra programar, mas pra navegar ou me aventurar no Photoshop. Meu antigo Macbook não funciona mais o track pad e é dependente do cabo da bateria, consequentemente virou DVD de luxo na sala =) .

Editor
Costumo usar mais o textMate porém desde o último Rails Rumble venho seguindo a moda e me aventurando no Vim. Nunca fui fã de aprender a dar um “combo” pra copiar arquivos, nem “meia lua pra frente soco forte” pra poder gravar arquivos, mas acabei gostando do Vim depois de uma série de deploys e tarefas de sysadmin. Uso Rails.vim, snipMate, surrond, ragtag e mais outros plugins.
Ultimamente tenho me aventurado em desenvolver pra Android, então o Eclipse está sempre aberto rodando o emulador.

Terminal
Terminal bash tradicional com algumas coisas no bashrc, gosto de um plugin chamado Visor e umas frescuras pras cores do terminal .
As abas costuma ser uma pro vim, rails console, ssh e outras pra tarefas adicionais.

Browser
Tenho usado o Chrome pra quase tudo, mas não largo o glorioso Firefox e o Firebug pra programação front end.

Software

• TweetDeck
• iTunes
• Adium/Skype
• VLC
• Quicksilver

Source-code
Git!

Música
Em casa de madrugada sempre com o fone, porém na Caelum aproveito pra aprender com as discussões que ocorrem toda hora, então fico só com um fonezinho branco em só um lado pra não perder nada

É isso, convido David Paniz, Adriano Almeida e Guilherme Silveira e o mestre Fabio Kung pra bincadeira.

O Rails 3 tem uma série de melhorias, mas nesse post quero tratar especificamente de uma, que é Modularidade.
Modularidade lembra de alguma forma baixo-acoplamento, fator indispensável para uma boa arquitetura.

Active Relation

Podemos analisar a questão da modularidade de várias maneiras, aqui vamos analisar usando o ActiveRelation.
O ActiveRelation permite querys muito mais interessantes, veja essa diferença entre Rails 2 e Rails 3.

O que percebemos nessa figura é que a nova API possui métodos muito mais intuitivos e interessantes
para criar querys. Alguns detalhes importantes aqui são:

• No Rails 2 o retorno já era um array com seus models. No Rails 3 cada método devolve um objeto chamado Relation
• Esse objeto Relation é capaz de fazer um encadeamento de operações. Com isso, auery final só é chamada quando
  executado explicitamente algum método como all ou each.
• No Rails 3 comportamento é Lazy Loading.

Visto isso, duas coisas podem ser analisádas:

• Como isso é feito por dentro?
• Como usar isso na minha app?

Internamente

Procurando internamente no fonte do Rails, encontramos o arquivo query_methods.rb. Esse é o arquivo responsável pela idéia de encadeamento:

Repare no código fonte. Independente do método chamado o Rails sempre faz uma cópia do encadeamento atual, adiciona um novo comportamento e devolve essa Relation atualizada. E quem é esse relation ?

relation é um método do ActiveRecord que verifica se o encadeamento já foi inicializado e decide por criar um novo ou devolver o mesmo.
Ainda temos na classe Relation um delegate, que roda o método to_a toda vez que o Relation for disparado. É nesse ponto que o Rails controla o hit no banco de dados. Interessante notar que o método find_by_sql ainda é utilizado, porém, com uma query
gerada pelo ARel.

Como melhorar meu código com isso?

O que não pode acontecer é apenas aceitar como funciona e usar a API. Esse encadeamneto abre novas possíbilidades de querys muito mais interessantes e otimizadas. Um ponto sempre complexo em aplicações são filtros que necessitam querys dinâmicas.

Filtros que necessitam muitos parâmetros com um número grande de combinações possíveis entre eles são complicados de fazer e manter.
Como tirar proveito do ActiveRelation pra melhorar isso ?

Se utilizarmos a mesma idéia de clonar o relation e devolve-lo de acordo com cada filtro preenchido pelo usuário, podemos montar uma implementação bem interessante com um pouco de meta-programação.

Repare que com um método filtered_relation podemos iterar sobre cada filtro possível, adicionando uma nova relation.
Cada relation é única e ensinamos como tratar com um método exclusivo.

Nesse caso utilizamos o ActiveRecord, mas hoje o Rails 3 não é opnionated. Até hoje, o Rails era considerado um
meta-framework, ou seja, um conjunto de frameworks, que juntos formavam o Rails.

No Rails 3, um componente central foi totalmente alterado para servir de fundação para o Rails. Todos os
considerados frameworks principais como ActiveRecord, ActionMailer etc deixaram de ser framewors e hoje são plugins.

O componente que organiza tudo isso é o Railtie. Todo plugin hoje é herda de Railtie. Ao inicializar o Rails,
o Railtie procura todos as classes que herdam de Railtie e começa sua inicialização. Nesse momento, cada plugin é responsável
pelo seu processo de boot, ou seja, desacoplado do Rails.

Se olhar os geradores, podemos entender como o Rails pluga os principais componentes(ActiveRecord, ActionController, etc)

Railtie + Plugins + ARel…

Se apartir do fonte do Rails criamos uma funcinalidade de filtro e se o Rails aceita fácilmente plugins hoje, por que não
juntar tudo agora ?

Podemos criar um plugin de filtros dinâmicos. Se você se interessar por ver o código ou contribuir, basta acessar o github do plugin filtered_relation

Os slides dessa apresentação estão no SlideShare

Porém muitos programas possuem estado compartilhado e precisam de funções não puras como essa para manter esse estado compartilhado.

Melhorando a função hello

Nossa função agora manterá um registro de todas as chamadas que forem feitas a ela. Para isso, usaremos um “set” do Clojure.

#{}
⇒
#{}


Como adicionar elementos nesse set ? Para isso utilizaremos um “conj“.
Conj é a significa conjoin de forma simplificada e ele cria novas coleções com os ítens adicionados.
Podemos então usar o conj com um elemento em um set.


(conj #{} "Anderson")
⇒
#{"Anderson"}

Agora que sabemos como criar “sets“, precisamos de alguma forma manter os registros das chamadas a nossa função hello.
Para isso, Clojure possui referencias (refs) e para nomear uma referência usamos def.

def é quase igual ao defn mas de uma forma mais generalista. Usando def podemos definir funções ou dados.
Usamos def para criar referências e associá-las a nossa função:


(def visitors (ref #{}))
⇒
#'user/visitors


E onde está esse controle de estados tão forte em Closure ?

O que acontece se tentarmos alterar essa referência que criamos ?
Vamos tentar fazer isso usando “alter“. Usando “alter” podemos tentar alterar nossa referência, inclusive passando argumentos se necessário. Vamos tentar alterar “visitor” para “visitors”.

(alter visitors conj "Anderson")
⇒
java.lang.IllegalStateException: No transaction running


Como vemos acima, clojure protege as referências. Podemos alterá-las mas precisamos de “transactions“, deixando para o Clojure o trabalho pesado de lidar com concorrêcia entre múltiplas chamadas a nossa função.

E como crio essa transaction ?
Para criar uma transaction usamos dosync.

(dosync (alter visitors conj "Anderson"))
⇒
#{"Anderson"}

Agora podemos buscar a referência com deref, veja:

(deref visitors)
⇒
#{"Anderson"}
@visitors
⇒
#{"Anderson"}


Agora podemos construir uma função hello muito mais avançada e elaborada:
(defn hello
"Returns a hello message, calling you by username.
Knows if you have been here before."
[username]
(dosync
(let [past-visitor (@visitors username)]
(if past-visitor
(str "Welcome back, " username)
(do
(alter visitors conj username)
(str "Hello, " username))))))

Vamos analizar um pouco mais da linguagem agora. Quando estamos no prompt, podemos imprimir usando a função println.

hello world
user=> (println "hello world")
| hello world
-> nil


A segunda linha é o output e a terceira linha, nil, é o retorno da função.

Definindo funções

Como toda linguagem você pode definir suas próprias funções:

user=> (defn hello [name] (str "Hello, " name))
⇒
#'user/hello


O que essa linha faz ?

• defn define uma função.
• hello é o nome da função.
• a função hello recebe um argumento, name.
• str é uma chamada a uma função que concatena argumento em uma string.

O valor de retorno é #’user/hello. O prefixo #’ indica que a função foi guardada em uma variável Clojure, e user é o namespace dessa função.

Usando funções

Uma vez criada a função e guardada em uma variável clojure, podemos chama=la:

user=> (hello "anderson")
⇒
"Hello, anderson"

Variaveis especiais

As variáveis que criamos e guardamos no Clojure continuam acessíveis:

user=> (hello "anderson")
"Hello, anderson"


user=> (hello "Caelum")
"Hello, Caelum"


E agora podemos combinar essas variáveis especiais:

(str *1 " and " *2)
⇒
"Hello, Caelum and Hello, anderson"


Por rodar na JVM, Clojure é muito relacionado com Java. A integração é bem simples e rápida, não necessitando nenhuma camada intermediária e, ao contraário da maioria das linguagens dinâmicas, clojure é rápido pois foi justamente escrito para tirar vantagens dos poderes de otimização das JVMs, podendo ser usada para diversos propósitos.

Clojure combina idéias vindas do Lisp, da programação funcional e lida com problemas de concorrência.

Instalando

Pra ver os primeiros códigos Clojure rodando é necessário baixar o arquivo cloujure.zip

Descompaacte o arquivo. Voce vai encontrar diversas pastas e arquivos, mas não se preocupe com isso agora.
Dentro dessa pasta crie um arquivo chamado clojure.clj (repare no .CLJ para arquivos clojure).
Vamos começar criando um teste ao invés do tradicional REPL. Não se preocupe em entender toda syntax agora, apenas vá se adaptando:

(ns clojure.test.example
(:use clojure.test))

(run-all-tests)

Rode no terminal com:
java -cp clojure.jar clojure.main -i clojure.clj

Quando tudo der certo você deve ver o seguinte output:

Testing user

Ran 1 tests containing 1 assertions.
0 failures, 0 errors.

Mais Clojure

Clojure equilibra conhecimentos de linguagens do passado com poderes das linguagens atuais.
Veja o exemplo abaixo:

//Java
public class StringUtils {
public static boolean isBlank(String str) {
int strLen;
if (str == null || (strLen = str.length()) == 0) {
return true;
}
for (int i = 0; i < strLen; i++) {
if ((Character.isWhitespace(str.charAt(i)) == false)) {
return false;
}
}
return true;
}
}

; Clojure
(defn blank? [s] (every? #(Character/isWhitespace %) s))

A versão Clojure é bem mais curta, mas o mais importante é ser mais simples. Não são necessárias nem variáveis. Isso é possível graças as chamadas “higher-order function” (funções que aceitam outras funções como argumento e/ou retornam funções como resultado). Além disso a versão Cljure é bem legivel. É como ler “uma string é vazia se toos os caracteres nela são espaços em branco”.


// java
public class Person {
private String firstName;
private String lastName;
public Person(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
}

; clojure
(defstruct person :first-name :last-name)


Person em Clojure é imutavel (Clojure também prove implementação correta de hash_code e equals automaticamente).

Definindo funções

(defn hello-world [username]
(println (format "Hello, %s" username)))

Clojure é uma linguagem funcional, mas não puramente como Haskell.
Funções podem ser criadas em runtime, retornadas, e normalmente usadas como um tipo como outro qualquer.
E nos tempos atuais, programação funcional é muito mais urgente que antes, devido aos avanços de hardware.

Clojure simplifica a programação concorrente, tornando fácil escrever código thread-safe.
Como estruturas imutáveis não mudam nunca, não existe risco de dados corrompidos por terem sidos utilizados
por outras threads. Tudo isso dentro da já consagrada JVM, onde inclusive, Clojure implementa funções simples
para uma série de interfaces Java.

Agora que já falamos sobre as características do Clojure, os próximos posts abordarão mais sobre código.

Tivemos a palestra do Akita

e uma minha sobre ActiveRecord.

Um dos próximos eventos da comunidade Ruby/Rails será o Ruby e Rails no mundo real.