O dia começou quente, 30º às 8 da matina. A princípio clima estranho, pessoas estranhas que não pareciam ser muito amistosas. Mas foi só começar as apresentações que as coisas mudaram de rumo. Boas e curtas apresentações, gostei desse modelo, mas descobri que tenho sérias dificuldades pra condensar conhecimento. Poxa vida, apresentar meses de queimação de massa cinzenta em 20 minutos é f*!()@, sem falar que o meu trabalho era sobre tolerância a falhas em Web Services e o público era apenas de tolerância a falhas. Crítico!

Acho que minha apresentação foi satisfatória, um pouco corrida porque não teve como não falar um mínimo de Web Services pra apresentar a solução. Ainda não vi se existe algum tipo de contrato de confidencialidade do artigo (se é só pra quem participou da LADC, ou não), assim que descobrir como publicá-lo na net eu o disponibilizo, ou pelo menos a apresentação.

Bem, além do conteúdo em si das apresentações, esse tempo sozinho em outra cidade me serviu para meditar sobre outras coisas.

A primeira delas é que nós PRECISAMOS divulgar aquilo que estudamos e as idéias que temos, sejam elas boas ou ruins. Às vezes o que é ruim, ingênuo ou simples em um contexto, pode não ser em outro. Com apresentações de 20 minutos dá pra aprender muita coisa, é um formato ideal. Tá certo que é muito mais difícil de fazer, o apresentador precisa apurar bastante a apresentação pra condensar sem jogar fora o essencial, mas para quem está assistindo é fundamental, justamente para poder ver várias, não só em relação ao tempo mas também em relação à capacidade de absorção. Tendo a idéia geral fica muito mais fácil digerir o artigo depois, caso haja interesse. Acho que o mesmo vale pra qualquer outro tipo de estudo e de idéias.

Estudou ou teve uma idéia? Apresente-a, não deixe as coisas se perderem.

É isso, amanhã, de Campo Grande, eu posto a parte final

Estou há algumas horas em João Pessoa/PB. Vim apresentar um artigo no Workshop de Tolerância a Falhas, pré-evento da LADC. O nordeste é mucho loco. De cara, o aeroporto de jampa não é em jampa, é em um cidade vizinha esquecida pela lei. Rapaz, pensa em um lugar que ninguém nunca ouviu falar em capacete, é lá. Saindo do aeroporto, peguei um táxi e aí tive certeza que leis de trânsito não existem para essas bandas. Primeiro que as lombadas estão desativadas, parece que conseguiram liminares pra derrubar as lombadas. Segundo que todo mundo desce o pé. Se você estiver a 100/h tem que andar na pista da direita.

Bem, enfim cheguei ao hotel que eu havia reservado pela Internet através de um e-mail apenas, o Victory Business Flat: http://www.victoryflat.com.br. Vou falar sobre ele (contando com o poder dos indexadores) porque não encontrei opniões sobre o mesmo na net antes de vir pra cá, o que seria muito útil. O hotel é decente, mas a R$ 130 a diária, era pra ser bem melhor, mas imagino que isso seja padrão aqui no nordeste. Ano passado no FISL em POA fiquei em um hotel em que a diária individual custava algo em torno de R$ 70 e ele era mais novo e os apartamentos eram só um pouco menores, um custo/benefício bem melhor, com certeza. O Victory também não é horrível, só é meio velhinho, mas o atendimento é bom e o restaurante zerado e bom, sem falar que a localização é muito boa.

Falando em localização, jampa me decepcionou um pouco. Não sei se é praia em que eu estou (tambaú), mas achei que o mar era caribenho. O mar é bom, calmo e a praia é limpa, mas sei lá, acho que é porque a praia tava vazia que talvez eu tenha ficado um pouco chateado Sem falar que ir à praia sozinho não tãããão legal assim, né? Mas é lógico que valeu a pena, após quase 10 anos (classe D é isso aí) voltar a rever o mar foi ótimo.

Agora vou descansar, ver o fantástico que amanhã cedo apresento o artigo. Na parte 2 eu falo sobre o WTF, propriamente dito, e coloco as fotos que eu tô tirando por aqui. See ya.

Apresentação feita na JavaOne sobre como tratar problemas de concorrência na prática:

Pra quem dá aulas (como eu) ou palestras/apresentações, de vez em sempre aparecem algumas situações em que o Compiz pode ajudar. Uma delas eu acabei de descobrir fuçando aqui (é, estou sem nada pra fazer em pleno sábado à noite) e resolvi compartilhar com vocês algumas dicas.

Bem, antes de mais nada, se você usa Ubuntu, eu recomendo a instalação do gerenciador de configuração do Compiz:

$ sudo apt-get install compizconfig-settings-manager

Agora sim, vai aparecer um novo item de menu: System -> Preferences -> CompizConfig Settings Manager. Isto aí nada mais é que uma telinha com um botão pra cada plugin do compiz disponível no seu sistema:

Agora vamos aos problemas. O primeiro pepino que pode dar em uma apresentação é quando a gente prepara um slide com várias informações, geralmente código, e fica lindo no monitor mas, na hora que projeta, fica pequeno. Lá vai o apresentador dar zoom, mexer com barra de rolagem e etc. Nestas ocasiões, o zoom do Compiz vem a calhar. Por default, basta apertar a tecla com o ícone do windows (que eles chamam de “super” só deus sabe porquê) e usar o scroll do mouse. O legal é que ele segura o zoom e conforme você vai mexendo o mouse a tela acompanha. +1 para o Compiz.

O segundo pepino que acontece com certa frequência é você utilizar cores que, ao serem projetadas, ficam fracas na parede (ou seja lá onde for que você estiver projetando). Isso é um troço chato. Uma solução na hora do desespero é selecionar o texto pra ver se dá um contraste, né? Bem, outra opção é usar a função “Negative” do Compiz. Basta pressionar Super + M e o Desktop fica que nem aqueles negativos de fotos. Não é 100% garantido, mas pode ser que ajude, né? Pra voltar ao modo normal de cores, basta pressionar Super + M novamente.

Por fim, a tal da funcionalidade que eu descobri hoje é a “Annotate”, que permite que você rabisque a tela e remova os rabiscos de maneira rápida e eficiente. Para rabiscar basta pressionar Alt + Super + Botão Esquerdo do mouse e arrastar. Aí manda ver nas anotações na tela. Quando você terminar de explicar, basta pressionar Alt + Super + k e pronto, a tela estará limpinha novamente. Se você fizer alguma caquinha no meio das anotações é possível pressionar Alt + Super + Botão Direito que, ao invés de rabiscar, o cursor vira uma borracha. Dessa funcionalidade eu gostei MUITO, muito útil mesmo, é quase uma “lousa digital”, né não? Indispensável para quem, como eu, não tem um daqueles apontadores “laser”

É isso aí que eu tinha pra compartilhar por hoje galera, t+.

Post escrito ao som de Radiohead.

Como se eles precisassem de ajuda

Quero ver esses caras na TV

É a única votação do VMB que parece ter sofrido um processo de seleção decente. Melhores twitters sem Marcelo Tas e Paulo Coelho? WTF? As votações musicais então, nem sem fala, tá feia a coisa.

Você já ouviu falar no pubsubhubbub?

Trata-se de um protocolo aberto para a criação de redes de servidores para publicação e assinatura de feeds. A página do projeto:  http://code.google.com/p/pubsubhubbub.

Let’s scale?

Update: Encontrei esse post também sobre HTTP callbacks: http://www.igvita.com/2009/06/29/http-pubsub-webhooks-pubsubhubbub/

Acabei de levar um tapa na cara, de mão aberta, do Ubuntu. Cá estava eu no meu note quando vem minha prima pedindo pra transferir umas fotos do celular ultra moderno que ela tem. Olhei pro bicho, pluguei o cabo USB, nada. Guri novo que sou, pensei: “vou pro Vista (que deixei esmagado em uma partição só deus sabe porquê). Chegando lá, pluguei de novo, nada. Lembrei: “putz, tem bluetooth”. Mandei o windows buscar… ficou meia-hora baixando isso e aquilo e meteu atualização no meio e num sei que lá, pra no final pedir o cd e dizer “não consigo”.

Voltei pro ubuntu, cliquei no ícone do bluetooth: “setup new device”, 5s, ok! Clico em “explore device”. Em mais 2s estou movendo os arquivos! FLAP, FLAP, FLAP!

Detalhe, o meu note é um PHILIPS que só eu sei como comprei (depois eu faço um review, porque tem quase nada na net e, quando o vêem, quase todo mundo fala ‘putz, um philips, nem sabia que esses caras faziam note’), instalei o ubuntu sem UM PERRENGUE sequer, tudo funcionando, inclusive compiz e tudo mais, coisa mais linda.

Ubuntu: DESCULPE-ME!

Alguns slides interessantes sobre código PHP legado (ruim) e como amenizar um pouco as coisas:

Apenas recentemente tive contato com um termo intrigante: Injeção de Dependências (Dependency Injection ou apenas DI). A primeira vez que eu o vi foi ao olhar alguns dos subprojetos do symfony que trata justamente disto. Após isto, vi outra notícia sobre injeção de dependências no Java 6. E isso tudo me deixou com uma pulga atrás da orelha, afinal, o que diabos é injeção de dependências? Para que isto serve? Nos parágrafos abaixo compartilho um pouco do que consegui aprender até agora.

Bem, a primeira coisa que eu descobri é que estamos falando apenas de mais um padrão de projetos. Em poucas palavras: Injeção de Dependências significa tirar de uma classe ou sistema a responsabilidade de instanciar suas próprias dependências [1]. Hmm, agora o termo já passa a fazer algum sentido. Já que o componente não vai mais instanciar, alguém terá que fazê-lo (injetar), certo?

E o que podem ser estas tais dependências e como instanciá-las? Considere que uma classe X precise de outra classe Y para funcionar. Uma maneira intuitiva de implementar X é instanciar um objeto de Y no construtor de X e utilizar os métodos desse objeto no restante do código de X. Se você quiser seguir o padrão de DI, entretanto, será preciso remover a instanciação de Y em X. Existem algumas alternativas para fazer esse desacoplamento:

• Fazer a injeção no construtor: uma instância de objeto da classe Y é passada como parâmetro do construtor de X.
• Fazer a injeção através de um setter: adicionamos um (ou vários) métodos à classe X especialmente para a definição de objetos das classes das quais X depende.
• Utilizar um localizador de serviços: um componente no sistema fica responsável por realizar o mapeamento dos componentes e suas dependências e instanciá-los em tempo de execução.

Resumindo para os mais pragmáticos, encontrei  uma definição mais prática, porém menos genérica, que irá sanar qualquer tipo de dúvida:

“Injeção de Dependências é passar as dependências de um componente através de construtores, métodos ou através da atribuição direta de campos”

Vamos agora ao exemplo em PHP. Suponha que tenhamos uma classe User no nosso sistema que armazena dados do usuário em sessão. A sessão será manipulada através de uma classe SessionStorage.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

class SessionStorage
{
  function __construct($cookieName = 'PHP_SESS_ID')
  {
    session_name($cookieName);
    session_start();
  }
  function set($key, $value)
  {
    $_SESSION[$key] = $value;
  }
  // ...
}
 
class User
{
  protected $storage;
  function __construct()
  {
    $this->storage = new SessionStorage();
  }
  function setLanguage($language)
  {
    $this->storage->set('language', $language);
  }
  // ...
}
 
$user = new User();

E se quisermos mudar o cookie name?

Bem, a alternativa mais óbvia é simplesmente adicionar o parâmetro à linha em que instanciamos SessionStorage na classe User (linha 20):

  $this->storage = new SessionStorage('SESSION_ID');

Outra alternativa seria configurarmos o nome através de uma constante:

1
2
3
4
5
6
7
8
9
10
11
12

 class User
{
  protected $storage;                        
 
  function __construct()
  {
    $this->storage = new   SessionStorage(STORAGE_SESSION_NAME);
  }
}
 
define('STORAGE_SESSION_NAME', 'SESSION_ID');
$user = new User();

Ou então, passar o nome como parâmetro para o construtor de User:

class User
{
  protected $storage;
  function __construct($sessionName)
  {
    $this->storage = new SessionStorage($sessionName);
  }
}
$user = new User('SESSION_ID');

Apesar de ser relativamente fácil de encontrar soluções semelhantes a estas em projetos por aí, nenhuma delas é ideal. Imagine que se queira agora trocar também o tipo de armazenamento (Sistema de Arquivos, Mysql, SQLite, etc). Como fazer?

Pode-se utilizar uma classe que realize o mapeamento, um registro:

  $this->storage = Registry::get('session_storage');

Neste caso, depende-se do registro. Por que, ao invés de instanciarmos o objeto responsável pela sessão de maneira hard coded no construtor, não injetamos a dependência (objeto manipulador de sessão) através de um parâmetro do construtor de User? Que tal?

class User
{
  protected $storage;
  function __construct($storage)
  {
    $this->storage = $storage;
  }
}
$storage = new SessionStorage('SESSION_ID');
$user = new User($storage);

Agora sim, não estamos mais instanciando a nossa dependência através do construtor, mas sim externamente. Caso queiramos trocar o tipo de armazenamento e os seus parâmetros de configuração, fazemos isto fora de User, por exemplo:

$storage = new MySQLSessionStorage('SESSION_ID');
$user = new User($storage);

Pra deixar as coisas ainda melhores, podemos padronizar um pouco mais a nossa classe, e utilizar uma interface como parâmetro do construtor:

function __construct(ISessionStorage $storage)
{
  $this->storage = $storage;
}
 
interface ISessionStorage
{
  function get($key);
  function set($key, $value);
}

E agora? E se quisermos testar a nossa classe User? Podemos usar um mock como meio de armazenamento, não?

class SessionStorageForTests implements ISessionStorage
{
  protected $data;
  function set($key, $value)
  {
    self::$data[$key] = $value;
  }
}

Prós:

• Podemos utilizar meios de armazenamento diferentes
• Configuração se torna natural
• É possível utilizar classes de terceiros (encapsuladas na interface) de maneira transparente
• Para testes, podemos usar mocks

Tudo isso de maneira simples, sem ter que alterar a classe User.

Contras

Sempre que se adiciona mais um nível de indireção, tem-se também um overhead associado. Em vista dos benefícios em relação à manutenibilidade do código e da facilitação para a realização de testes, principalmente, creio que seja um custo que valha a pena, não?

Perde-se parte do encapsulamento de uma classe ao se expor suas dependências. Além disso, dificulta-se um pouco a sua utilização, afinal, em teoria temos que instanciar as dependências sempre que quisermos utilizá-la. Em teoria, porque na prática podemos utilizar ferramentas que realizam essa tarefa para nós. Em breve espero escrever algo sobre o componente do symfony, que na realidade dá pra ser usado em qualquer projeto, não apenas naqueles baseados em symfony, legal né?

Para saber mais:

[1] The Dependency Injection Pattern – What is it and why do I care?

[2] Inversion of Control Containers and the Dependency Injection pattern do Martin Fowler (artigo mais referenciado sobre o tema)

Os exemplos foram copiados (de maneira resumida) desta apresentação:

http://fabien.potencier.org/talk/19/decouple-your-code-for-reusability-ipc-2008

Outra apresentação bem legal sobre DI em PHP:

http://www.procata.com/talks/phptek-may2007-dependency.pdf

Bem, como eu disse no post anterior, andei estudando um pouco alguns dos frameworks mais atuais: Django, Rails, Cake e Symfony. Além de já ter me aventurado um pouco com o Zend. Todos são muito bons, mas como estou trabalhando com PHP no momento, resolvi explorar o Symfony um pouco mais a fundo. O Cake também é bem legal, não pretendo perdê-lo de vista, mas não dá pra aprender dois ao mesmo tempo, dá? Até porque os dois visam a resolver o mesmo poblema. Escolhi o Symfony porque ele me pareceu ser um pouco mais maduro: console, ORM (Doctrine) e documentação.

Bem, pra começar quero compartilhar uma apresentação que eu vi agorinha, que fala um pouco sobre Symfony + YUI (Yahoo User Interface):

Eu já tinha visto a YUI há algum tempo e tudo mais. Não estou apto a afirmar que ela seja melhor que a JQuery e afins e nem sei se o foco é o mesmo, aparentemente sim. Mas gostei da estrutura do projeto, o site é bem maduro. Entre as várias funcionalidades, a que me chamou mais a atenção foi a Grids CSS, por enquanto. O mais legal mesmo é que tem um construtor online de interfaces, o CSS Grid Builder que gera layouts em CSS com a promessa de funcionar em qualquer browser. Fala aí se não é uma mão na roda pra quem é só programador e não está nem um pouco afim de ficar lutando com browser? Achei ótimo.