Os objetos estão te matando?

Ou é você quem acha que a culpa é deles?

Hoje eu achei um exemplo de código ruim atribuído ao uso de objetos. O interessante é que se você olhar bem, o código na verdade é procedural. Só porque você está usando uma linguagem ou biblioteca com suporte a orientação a objetos, não quer dizer que você esteja programando orientado a objetos. Este é um engano bastante comum. Você já deve ter conhecido algum sistema por aí que parece ter sido construído sobre duas exigências básicas:

1. Usarás uma linguagem orientada a objetos
2. Escreverás somente código procedural

Dava até pra colocar numa tábua de mandamentos.

O objetivo do código do exemplo de Jeff Attwood que disparou este artigo é renderizar um trecho de XML. Vamos dar uma olhada:

1   System.Text.StringBuilder sb =
      new System.Text.StringBuilder();

    XmlWriterSettings xs = new XmlWriterSettings();
    xs.ConformanceLevel =
      ConformanceLevel.Fragment;
5   xs.Indent = true;

    XmlWriter xw = XmlWriter.Create(sb, xs);
    xw.WriteStartElement("status");
    xw.WriteAttributeString("code", "1");
10  xw.WriteEndElement();
    xw.WriteStartElement("data");
    xw.WriteStartElement("usergroup");
    xw.WriteAttributeString("id", "usr");
    xw.WriteEndElement();
15  xw.WriteEndElement();
    xw.Flush();
17  return sb.ToString();

Este trecho de código é totalmente procedural, e foi escrito usando uma linguagem e uma biblioteca de objetos (acho que isso é C# junto com alguma biblioteca .Net para XML). A grande estrela desse código é o objeto conhecido por 'xw'. Ele aqui está sendo usado como um elemento passivo, mero cumpridor de ordens. Tudo que ele precisa fazer é explicitamente requisitado:

— Xw, comece a escrever um elemento 'status'.
— Sim, senhor!
— Xw, escreva um atributo chamado 'code' com valor '1'.
— Sim, senhor!
— Xw, está bom, pode fechar este elemento.
— Sim, senhor!

... e assim por diante. Dar ordem expressas assim é característica de código procedural, que se confunde com o código imperativo. E código imperativo tem esse nome justamente porque é estruturado ao redor de um conjunto de comandos (ou ordens) básicos.

Esse tipo de argumento anti-objetos parece acontecer muito mais por causa da interface de uma biblioteca do que pelo uso de objetos. Bibliotecas diferentes vão ter interfaces diferentes. Este trecho de código Ruby enviado por um leitor do blog dele exemplifica bem:

  builder = Builder::XmlMarkup.new(:target=>STDOUT,
                                   :indent=>2)
  builder.person { |p|
     p.name("Jim")
     p.phone("555-1234")
  }

Aqui o estilo é muito mais declarativo. Quase idêntico a escrever o código XML você mesmo, mas sem os perigos de se tentar escrever manualmente em uma linguagem feita para máquinas.

A questão aqui não é a dicotomia orientado-a-objetos x procedural. Talvez isso nem exista. Como o exemplo em C# mostra, é possível escrever código procedural orientado a objetos. Além de possível, é bastante comum. A discussão na verdade é entre os estilos declarativo e procedural.

Quem será que ganha essa última?