Type-safe null usando Option

Reconhecendo o erro bilionário

Em 1965, Sir Charles Antony Richard Hoare (Tony Hoare para os chegados), inventava o null, as referências nulas, enquanto projetava a linguagem orientada a objetos ALGOL W.

Muitos anos depois, em 2009 ele mesmo retoma esse fato em uma palestra:

I call it my billion-dollar mistake.

Ele chama o null de seu erro bilionário! Fonte de inúmero erros, vulnerabilidades e problemas em sistemas no mundo todo. De fato uma grande cagada!

O Problema e sua Consequências

Certamente o null é tratado com muita cautela por nós programadores quando escrevemos nosso código. Sendo profissionais cautelosos, sempre pensamos que uma ou outra referência pode estar nula, desconfiados de toda e qualquer variável.

O programador Java incauto, faria coisas do tipo:

Animal elefante = animais.get("elefante"); 
elefante.anda(); // Pode dar merda
Pessoa p = PessoaDAO.findByName("Felipe");
Documento d = p.getDocumento(); // Vai dar merda
d.getNumero(); // Já deu merda

Já o programador cauteloso e experiente não se arriscaria a tomar um NullPointerException na cara:

Animal elefante = animais.get("elefante");
if(elefante != null)
  elefante.anda();  // Agora é seguro
Pessoa p = PessoaDAO.findByName("Felipe");
if(p != null) {
  Documento d = p.getDocumento();
  if(d != null) { 
    d.getNumero();  
  }
}

Ser desconfiado dá trabalho, e deixa nosso código cheio de if-guards, que são feios e chatos de ler.

Claro que, com um bom design, é possível diminuir a quantidade de ifs, mas o grande problema é que eventualmente alguém vai esquecer do maldito if e um NullPointerException (ou Segmentation Fault) poderá explodir a qualquer momento em produção!

O problema é que o compilador não nos diz nada. Se fosse possível fazer o compilador trabalhar para gente, e pegar todos esses erros em compilação seria ótimo…

Evitando o erro

Muitas pessoas inteligentes perceberam o risco de se ficar manipulando nulls e inventaram maneiras para evitar seu uso.

Null Objects

Um exemplo é o pattern Null Object, que sugere a construção de objetos “sem comportamento” como uma alternativa.

O grande problema desses Null Objects é que se forem usado sem cuidado, podem introduzir bugs difíceis de se encontrar, pois eles de certa forma disfarçam o problema. Imagine: você tem um objeto na mão, chama alguns métodos sem nenhum problema só que na verdade esses métodos não estão fazendo nada.

Option

Um conceito muito interessante e bastante simples, trazido diretamente do mundo da programação funcional é o do tipo Option, também chamado de Maybe em algumas linguagens.

O Option é um tipo abstrato parametrizado (portanto Option[T]) que tem apenas dois filhos: Some[T] e None. De maneira muito simplificada, em Java seria algo do tipo:

public abstract class Option<T> {
	  public static <T> Option<T> of(final T conteudo) {
		if(conteudo == null) {
			return new None<T>();
		} else {
			return new Some<T>() {
		    	public T get() {
		    		return conteudo;
		    	}
		    };	
		}
	  }
}

abstract class Some<T> extends Option<T> {
  public abstract T get();
}

class None<T> extends Option<T> {}

Usamos o Option assim:

Option<String> some = Option.of("Tem coisa"); // devolve Some<String>
Option<String> none = Option.of(null); // devolve None

Portanto, sempre que uma função tem a possibilidade de devolver um valor inválido ou inexistente para determinado argumento, podemos embrulhar o resultado em um Option.

Por exemplo:

Option<Pessoa> pessoa = pessoaDAO.findById(1234L); 

Legal, dessa maneira pessoa nunca será null, mesmo que o registro 1234 não exista no banco de dados.

Só que quando eu quiser o conteúdo do Option, teria que fazer isso:

if(pessoa instanceof Some<?>) { 
  String nome = ((Some<Pessoa>) pessoa).get().getNome(); 
  System.out.println("Encontrei pessoa com nome: " +  nome); 
} else {
  System.out.println("Não encontrei ninguém");
}

Esse código, apesar de terrivelmente feio, é mais type-safe, já que o compilador nos força a fazer uma verificação antes de usar a instância de Pessoa.

Outra desvantagem dessa abordagem é que, além de ser desengonçado, é mais prático fazer um if(pessoa != null) . Por isso é difícil convencer um programador a usar isso. E agora?

Bom, em Scala e em outras linguagens mais funcionais temos Pattern Matching para melhorar as coisas:

Option<Pessoa> pessoa = pessoaDAO.findByPK(1234L); 
pessoa match {
  case Some(p) => println("Encontrei pessoa com nome: " + p.nome)
  case None => println("Não encontrei ninguém")
}

Ainda um pouco verboso, mas bem melhor!

Pattern Matching é ideal quando temos dois fluxos completamente diferentes dependendo se o Option é Some ou None. Para casos em que só se quer passar o valor para uma função, ou manipulá-lo de maneiras mais simples, podemos usar as construções apresentadas na próxima seção.

Indo um pouco além do óbvio

Option surgiu no mundo funcional, e é muito mais do que um simples container de coisas.

Na realidade, é possível manipular um Option de maneiras muito práticas e poderosas, especialmente em linguagens em que conseguimos passar funções como parâmetro. Essas construções geralmente são mais enxutas do que fazer Pattern Matching.

Tony Morris fez um post em seu blog mostrando algumas formas mais funcionais de se substituir diversos casos implementados com Pattern Matching, usando a própria API do Option.

Veja alguns exemplos em Scala:

Option<Pessoa> pessoa = pessoaDAO.findByPK(1234L);  // mesmo exemplo

// foreach
// Se for Some executa a função passada, se for None não faz nada.
pessoa.foreach(p => println(p.nome))

// map
// Se for Some executa a função e embrulha o retorno em um Option. Se for None devolve None.
val endereco:Option[Endereco] = pessoa.map(_.endereco) 

// getOrElse
// Se for Some devolve o conteúdo, se for None devolve o resultado do bloco passado como parâmetro
val p = pessoa.getOrElse(new Pessoa())

Note que muitos métodos de Option são os mesmos que existem nas Collection em Scala.
E pasmem, é possível usar Option em for-comprehensions, podendo até misturar listas com options.

val lista:List[Integer] = List(1,2,3)
val option:Option[Integer] = Some(1)

// Conhecemos for em listas
for( num <- lista) {
  println(num)
}

// Mas é possível usar Option
for(num <- option) {
  println(num)
}

Imagine que você quer navegar por uma estrutura de objetos cujos métodos retornam Option. É possível usar uma construção for sofisticada em Scala:

for { 
  pessoa <- pessoaDAO.findByPK(1234L)  
  endereco <- pessoa.getEndereco
  numero <- endereco.getNumero 
} {
  println("O número da casa da pessoa de ID 1234 é " + numero)
}

Se em alguma dessas linhas, o objeto for um None, o corpo do for não será executado. É como se um Option fosse uma lista de um único elemento.

Por fim…

Option é uma poderosa abstração para substituir o famigerado null, causa de tantos NullPointerExceptions inesperados.

Seu objetivo é tornar o código mais type-safe e, mesmo adicionando uma camada extra para alcançar isso, sua API engenhosa permite que o programador manipule os Option de maneiras muito eficientes, concisas e poderosas.

Quando estiver projetando uma API, considere o uso de Option em funções que podem ou não devolver um objeto. Use para tratar os casos de exceção, como por exemplo quando um registro não é encontrado no banco de dados, ou quando uma função não está definida para determinado argumento.

Anúncios

Design Patterns em Scala – Parte 2: Decorator

No post anterior dessa série de Design Patterns falamos um pouco sobre maneiras diferentes de se implementar o pattern Observer em Scala.

Agora vejamos como as Traits podem nos ajudar a “decorar” nossas classes em runtime, com o Pattern Decorator.

Decorator

Muitas vezes quando queremos adicionar um comportamento a alguma classe, pensamos logo em herança, só que herança nem sempre é o melhor caminho. Vejamos o famoso exemplo das Janelas (decoração, janelas… acho vou mudar de ramo.).

Suponha uma classe que desenha uma janela simples na tela.

class Janela {
  def renderiza() = {
    print("Desenhando janela") // Use a imaginação cara!
  }
}

Ótimo, só que em um sistema de janelas, podemos ter diversos tipos de janelas, cada uma com uma combinação de funcionalidades:

  • Janela com barra de título
  • Janela com scroll vertical e barra de título
  • Janela com scroll horizontal, barra de título e barra de status
  • etc etc etc

Já de cara podemos ver que é impraticável criar uma subclasse para cada tipo de janela.

Aí vem a sacada do Decorator: ao invés de herança vamos usar composição e compor, a partir de pedaços de funcionalidade, a janela que quisermos. Tudo em runtime.

Vamos ver como implementar em Java da maneira chata usual:

// Interface implementada pela classe e pelos seus decorators
public interface Janela {
  public void renderiza();
}

// Decorator tem que manter controle de quem ele está decorando
abstract class JanelaDecorator implements Janela {
  private Janela janela;

  public Janela getJanela() {
    return this.janela;
  }

  public JanelaDecorator(Janela janela) {
    this.janela = janela;
  }

  public abstract void renderiza();
}

class JanelaSimples implements Janela {
  public void renderiza() {
    System.out.print("Desenhando Janela");
  }
}

class ScrollBarDecorator extends JanelaDecorator {
  public ScrollBarDecorator(Janela janela) {
    super(janela);
  }

  public void renderiza() {
    this.getJanela().renderiza();
    System.out.print(" com ScrollBar");  // Decorator adiciona comportamento
  }
}

Então, quando você tiver um monte de decorators implementados, você pode começar a decorar suas janelinhas:

Janela j = new ScrollBarDecorator(new JanelaSimples());
j.renderiza();
// Desenhando Janela com Scrollbar

// Você pode decorar com quantos decorators quiser.
Janela j = new ScrollBarDecorator(new TitleBarDecorator(new StatusBarDecorator(new JanelaSimples())));

Muito legal, mas eu só mostrei isso para você poder comparar com Scala.

Em Scala podemos fazer isso usando Traits:

// Nossa Janela
class Janela {
  def renderiza = print("Desenhando Janela")
}

// Quando uma Trait estende uma classe, ela só poderá ser misturada a objetos daquela classe. E também, "super" irá se referir à classe a qual ela foi misturada, ou outra Trait que foi misturada na classe.
trait ScrollBar extends Janela {
  override def renderiza = {
    super.renderiza
    print(" com Scrollbar")
  }
}

// Vamos usar
val janela = new Janela with ScrollBar
janela.renderiza 

// Desenhando janela com Scrollbar

Só isso! Meus dedos agradecem a redução de linhas.

E também aqui você pode usar quantos decorators quiser, separando as Traits com a palavra-chave with:

// "super" sempre vai se referir ao elemento da esquerda. 
val janela = new Janela with ScrollBar with StatusBar with TitleBar with Resize with BolinhasVerdes

Nesse exemplo, quando invocamos o método renderiza() no objeto janela, o primeiro
método a ser chamado é o da Trait a extrema direita BolinhasVerdes. A medida em que invocamos o método em
super, estamos referenciando a Trait logo a esquerda, até chegar na classe Janela.

É assim que funciona a composição de Traits.

Por hoje é só pessoal, e no próximo capítulo sobre Design Pattern:

Pimp My Library

Design Patterns em Scala – Parte 1: The Observer

Todo programador moderno, hype, antenado, ligado nas tendências, curte mesmo um Design Pattern.

Aliás tudo que tem Design no nome fica chique né? “Design de Sombrancelhas”, “Hair Designer”. Mas enfim…

Design Patterns é de fato um assunto bastante interessante, e o conhecimento de alguns desses padrões de design pode facilitar bastante o desenho de soluções.

Nesse post não pretendo ficar explicando a fundo os Patterns mais conhecidos no mundo Java, tem muita coisa já escrita por aí.

Como o foco principal desse blog é a linguagem Scala, vamos dar uma olhada em como alguns Patterns manjados em Java ficam ainda mais interessantes em Scala. Em seguida, vamos ver alguns Patterns novos para Scala.

Singleton

object MySingleton {
 // Código vai aqui
}

Singleton foi elevado ao cargo de construção de linguagem! Usando a palavra-chave “object” estamos criando uma instância única de uma classe.

No exemplo acima estamos ao mesmo tempo declarando uma classe e instanciando um singleton para ela.

Um singleton pode naturalmente estender classes e implementar Traits.

// Nem preciso de corpo se eu não quiser
object MySingleton extends MyClass with MyTrait 

O ministério da saúde dos programadores adverte: Singleton faz mal aos testes. Use com consciência.

Observer

Como vocês já sabem, nesse padrão temos dois personagens principais: o Observer, e o Subject.

O Observer é o objeto que está interessado no que o Subject está fazendo, e o Subject é gentil em notificar os Observers quando algo nele muda.

Primeiro, vejamos o jeito mais conhecido, java-like:

trait Subject {
  private var observers: List[Observer] = Nil

  def addObserver(observer: Observer) = observers = observer :: observers

  def notifyObservers() = observers.foreach(_.receiveUpdate(this))
}

trait Observer {
  def receiveUpdate(s:Subject)
}

// Olha mãe, sou um Singleton
object MyObserver extends Observer {
  def receiveUpdate(s:Subject) {
    println("O subject mudou!")
  }
}

// Olha mãe, eu nem preciso de um corpo
object MySubject extends Subject

// Testa tudo isso aí
MySubject.addObserver(MyObserver)
MySubject.notifyObservers

Criamos uma Trait para o Subject e o Observer e um exemplar concreto para cada um apenas para ver funcionando.

Uma Trait é como se fosse uma interface Java que também pode ter campos concretos. Uma classe consegue “estender” múltiplas Traits.

Só que em Scala eu consigo deixar as coisas mais interessantes. Vamos dizer que você não queira uma interface para os Observers. Que tal se qualquer classe que tiver o método receiveUpdate(s:Subject) pudesse ser um Observer?

Podemos usar Structural Typing para isso, e jogar a Trait Observer fora:

// Subject agora aceita qualquer observer que se "encaixa" no type definido
trait Subject {
  // Adicionei esse Type Alias para dar um nome a esse tipo estrutural.
  type Observer = { def receiveUpdate(s:Subject) }

  private var observers: List[Observer] = Nil
  def addObserver(observer: Observer) = observers = observer :: observers
  def notifyObservers() = observers.foreach(_.receiveUpdate(this))
}

// Não estende nada
object MyObserver {
  def receiveUpdate(s:Subject) {
    println("O subject mudou!")
  }
}

// O resto é igual
object MySubject extends Subject

MySubject.addObserver(MyObserver)
MySubject.notifyObservers

Structural Typing é parecido com Duck Typing, se o objeto tiver aquele método, ele é chamado. Por baixo dos panos o compilador resolve tudo usando Reflection, e por isso talvez tenha um impacto na performance do código.

Agora, uma instância de qualquer, QUALQUER classe que possua o método receiveUpdates(s:Subject) pode se adicionado como um Observer.

Legal, mas podemos ir além! E se eu não quiser que meu Observer seja uma instância de uma classe? Que tal se ele fosse apenas uma função?

Sinta o poder:

trait Subject {
  // Type Alias novamente. O tipo Observer é qualquer função que recebe Subject como parâmetro e não devolve nada (Unit é tipo void).
  type Observer = (Subject => Unit)

  private var observers: List[Observer] = Nil

  def addObserver(observer: Observer) = observers = observer :: observers

  // Mudei aqui para executar a função ( .apply aplica uma função )
  def notifyObservers() = observers.foreach(_.apply(this)) 
}

// Olha mãe, sou uma função!
val updateHandler = (s:Subject) => println("O subject mudou!")

object MySubject extends Subject

// Testa
MySubject.addObserver(updateHandler)
MySubject.notifyObservers

Type Alias é uma construção que permite que você defina um tipo. Isso mesmo, você declara um tipo e dá um nome para ele. Por exemplo, você pode dar um nome diferente para o tipo String:
type MinhaString = String.
Isso é bastante útil com Structural Typing.

Eu sei, eu sei, foi uma viagem e tanto. Se você nunca tinha experimentado nada do mundo funcional, esse aqui foi um pequeno exemplo.

Isso aí, vimos como em Scala podemos escrever o Observer de maneiras diferentes, tornando-o mais flexível.

Se o seu Observer não puder por algum motivo implementar uma interface, ou estender uma classe específica, podemos usar Structural Typing!

Se você não quer criar uma classe só para ser um Observer, e quiser só passar uma função de callback para seu Subject, agora você também pode de maneira simples e concisa. (em Java até daria para fazer uma classe anônima, mas convenhamos que assim é 3430943498 vezes mais bonito).

No próximo capítulo!

Arquitetura e Decoração com o Decorator

E não, não estamos falando sobre jardim, sofás, paredes e decoração de interiores…

View-first vs. MVC – Por que Lift é diferente?

Se você, caro leitor, desenvolve ou já desenvolveu aplicativos Web, deve estar cansado de ver essas três famigeradas letras: MVC, acrônimo de Model-View-Controller.

Se você programa em Java com Struts, sabe muito bem o que é uma Action.

Se você programa em Ruby com Rails, domina os ApplicationControllers.

Se você programa em PHP não tem idéia do que eu estou falando. Brincadeira! (perco o leitor mas não perco a piada).
Se você programa em PHP com CodeIgniter está bastante acostumado com os Controllers.

A arquitetura MVC reina absoluta entre os frameworks Web. Mas vamos lembrar porque é interessante fazer as coisas assim.

MVC e a separação de interesses

E o que essa arquitetura tem de tão fantástica? Ela simplesmente busca manter as coisas separadas. Modelo é modelo, apresentação é apresentação, não vamos bagunçar tudo em um grande bolo-fecal.ASP.
(Se você nunca mexeu em um grande arquivo .ASP de 3000 linhas cheio de HTML entremeado de lógica de negócio – e bugs -, e acha que ‘bolo fecal’ é ofensivo, é porque você tem sorte e não teve que ver essa nojeira!).

Apesar da quantidade de lógica que “vaza” para a camada de apresentação depender do framework que implementa o MVC, do engine de template que é usado e da disciplina do programador, o objetivo do MVC até que foi cumprido com sucesso.

Se você pegar uma aplicação razoavelmente bem feita, usando algum framework MVC poderá ver com clareza todas as classes do modelo, todas as classes que são os controller e todos os arquivos das Views.

De vez em quando, o desenvolvedor pode colocar uma lógica ou outra no template da View. Mas além disso, as coisas estão até que bem separadas.

O Lift ganha pontos aqui porque, ao contrário de PHP, ASP, JSP e outros engines de template, não é possível colocar lógica na View. Uma view em Lift é um simples XHTML e nada mais. É um modelo semelhante ao praticado pelo Apache Wicket.

MVC e uma lógica principal

Vamos pensar aqui, em linhas bem gerais, como é a fluxo de uma Request em um framework MVC:

  1. Chega uma Request para uma URL myApp/myController
  2. O framework mapeia essa URL para algum método do Controller MyController
  3. Esse método faz alguma lógica de negócio, e devolve algo que será no fim das contas a View
  4. A View, com base no estado do Model e do Controller mostra o que tem que mostrar na tela.

Perceba que a request no MVC está atrelada a uma lógica principal, que é basicamente o método invocado no Controller. Vamos tentar exemplificar.

Suponha que eu queira fazer uma tela para listagem de produtos e uma tela para edição de um produto específico. Eu teria as seguintes URLs.

/produtos/listar
/produtos/editar?prod=1234

E meu Controller teria dois métodos, um responsável por montar a tela de listar e o outro pela tela de editar.

Isso até que funciona muito bem, é fácil de fazer e de manter. O problema, é que atualmente, as aplicações Web estão ficando cada vez mais complexas, de modo que uma tela contém inúmeras funcionalidades concomitantes:

Uma tela de listagem de produtos, não apenas lista produtos. Na mesma tela temos uma lista de produtos no meio, um carrinho de compras mostrando o total de produtos na direita, uma lista de produtos sugeridos embaixo, e ainda um chat em tempo real no cantinho.

Já começa ficar complicado orientar nossa aplicação pelo Controller. Se pensarmos que o Controller vai se preocupar com a funcionalidade principal, temos que escolher uma para ele. Se escolhermos a listagem de produtos, quem vai cuidar da renderização das outras funcionalidades?

E ainda por cima, queremos manter nossas classes coesas e nossa View livre de lógica de negócio! Aí complicou.

Lift e a arquitetura “View First”

Foi pensando nesses cenários, muito comuns nas aplicações Web de hoje, que o criador do Lift, David Pollak, resolveu não seguir a abordagem MVC. Ao invés disso ele pensou em uma estratégia que é conhecida no meio como “View First”.

Nessa arquitetura o ponto de acesso de nossas páginas não é o Controller, mas a View. Pense assim, é a View que vai definir o que vai ter na tela e onde essas coisas vão aparecer.

Então cada um desses “blocos de funcionalidade” será mapeado para um Snippet. Cada pedacinho da tela será renderizado por um Snippet diferente, de uma maneira bastante componentizada.

Um Snippet é o equivalente Lift de um Controller, só que no caso é a View quem “chama” o Snippet, e não o contrário.

Vamos ver uma View em Lift, que nada mais é que uma página XHTML:

<!-- Topo -->
<div class="lift:Usuario.boasVindas">
 Bem vindo, <span id="usuarioLogado" />
</div>

<!-- Listagem de produtos -->
<div class="lift:Produtos.lista">
  <ul id="produtos">
    <li id="produtoItem">Produto1 - 9,99</li>
  </ul>
</div>

<!-- Chat Real Time em Comet -->
<div class="chatWindow">
  <div id="mensagens">
    <ul class="lift:comet?type=Chat">
      <li>Line 1</li>
      <li class="clearable">Line 2</li>
      <li class="clearable">Line 3</li>
    </ul>
  </div>
  <form class="lift:Form.ajax">
    <input class="lift:ChatIn" id="chat_in">
    <input type="submit" value="Chat">
  </form>
</div>

Observe que nessa View temos três funcionalidades bem distintas:

  • Um topo com uma mensagem personalizada para o usuário logado, que possivelmente pode ser reaproveitado em todas as telas do sistema.
  • Uma listagem de produtos.
  • Uma janelinha de Chat real-time usando Comet.

Essa View, que poderíamos chamar de /produto/lista.html agora é o ponto de entrada da nossa Request. A partir dessa View serão chamados três diferentes Snippets, cada um responsável por renderizar um pedacinho da View!

O interessante dessa abordagem “View First” é que podemos facilmente criar componentes utilizando os Snippets, e reaproveitá-los em diferentes Views.

Não vou focar muito nos Snippets agora, mas para você, curioso leitor, uma amostra do que poderia ser o Snippet de listagem de Produtos. Note como é sucinto, rápido, prático, bonito, elegante, charmoso, funcional etc etc :

object Produtos {
  def lista = {
    "#produtoItem" #> Produto.findAll.map(p => p.nome + " - " + p.preco)  
  }
}

A ligação com o elemento da view é feito por uma espécie de Seletor CSS. Nesse caso estamos pegando o <li id="produtoItem"> e repetindo para cada produto encontrado no modelo.

Moral da História

Nesse post relembramos um pouco da filosofia MVC e os motivos que levaram a sua concepção e aprendemos um pouco sobre a filosofia “View First” que é um dos fundamentos do framework Lift.

Para os iniciantes em Lift, essa mudança de filosofia pode ser meio estranha, podendo causar um pouco de confusão, desconforto, nojo, náuseas, já que a imensa maioria dos desenvolvedores Web esta bastante acostumada com o MVC.

Minha sugestão é: Faça um teste, brinque um pouco com o Lift para sentir um pouco essa arquitetura.

Você pode acabar gostando.