Wednesday, February 23, 2011

Linguagem Ubíqua para dentro do código-fonte


"We understand each other"  (James Shore)

  • Seu código-fonte é um verdadeiro caos, impossível de compreender até mesmo pelo programador que o escreveu?
  • Se algum dos programadores da sua equipe abandonar o trabalho hoje, os demais serão capazes de continuar o serviço tranqüilamente?

Live Source é um Web Toolkit que auxilia na criação de uma linguagem ubíqua e estende as vantagens que o código-fonte pode proporcionar ao seu processo de desenvolvimento.

 
A idéia é provar que a linguagem ubíqua pode ser utilizada até nos níveis mais técnicos do software incluindo o próprio código-fonte, sem nenhum efeito prejudicial ao processo de desenvolvimento

Observe os exemplos abaixo e envie-nos seus comentários a respeito das opções que estamos demonstrando.



Uma Story ANTES DEPOIS da Linguagem Ubíqua

A utilização da linguagem ubíqua deve começar nos mais altos níveis de interação do projeto, como emails, documentos de planejamento, User Stories, etc. Para o programador aplicar a linguagem ubíqua no código-fonte com facilidade, os termos já devem estar no seu sub-consciente, sendo utilizados com freqüência pelo resto da equipe.
Observe as duas histórias de usuário abaixo e verifique que a simples aplicação dos termos de domínio nos artefatos do projeto não afeta em nada a mensagem a ser transmitida.



(Exemplos extraídos de um software para jogar o Jogo da Velha)

ANTES    
Mover
     Quando o usuário clica no grid,
     o sistema exibe 0 ou X dependendo de qual é o usuário atual.  



DEPOIS   
Movimento do Jogador
Quando o jogador clica no tabuleiro,
o jogo exibe o símbolo 0 ou X dependendo de qual é o        
jogador atual.





Uma classe ANTES DEPOIS da Linguagem Ubíqua

A partir de histórias já escritas com a linguagem do domínio fica mais imediato para o programador identificar os jargões ténicos que devem ser evitados durante a programação.
Perceba o quanto a análise é facilitada quando o programador aplica a linguagem ubíqua diretamente no código-fonte. A quantidade de suposições a respeito de sua lógica e suas intenções é bastante minimizada para aqueles que forem manter ou estender esse código, diminuindo consideravelmente a possibilidade de futuros erros.

(Exemplos extraídos de um software para jogar o Jogo da Velha)

ANTES    
/**
 * Exibe a string O ou X na celula do jogo.
*/
public class  MostraCellGrid{

public static void  
exibeUsuario(Grid grid, Cell cell) {

  
       if
 (!Inicializacao.flag


  && Inicializacao.statusJogo.getSequencia() == null
  && isVazio(gridcell)) {

 Inicializacao.flag = true;

 String mk= exibeString(Inicializacao.statusJogo
       .getUsuarioCorrente().getStringUsuario());

 grid.setHTML(cell.getRowIndex(), cell.getCellIndex(), mk);

 Inicializacao.statusJogo.getStatus()[cell.getRowIndex()][cell
.getCellIndex()] = Inicializacao.statusJogo
.getUsuarioCorrente();

GameEnd.verificaFim(Inicializacao.statusJogo,
cell.getRowIndex(), cell.getCellIndex());
       }
(...)
}



DEPOIS   
/**
 * Efetiva o movimento do jogador na grade do jogo. 
 */
public class MovimentoDoJogador {


/**
* Quando o jogador clica numa celula na grade do tabuleiro o jogo desenha
* um 0 ou X dependendo de qual e o jogador atual.
*/
       public static void mover (GradeDoJogo gradeDoJogoCell celulaSelecionada) {

if (!VariaveisGlobais.flagDeAguardoDoMovimento
&& VariaveisGlobais.statusCorrenteDoJogo.getSequenciaGanhadora() == null
&& eCelulaVazia(gradeDoJogo, celulaSelecionada)) {

VariaveisGlobais.flagDeAguardoDoMovimento = true;

String simbolo = exibeSimboloDoJogador(
VariaveisGlobais.statusCorrenteDoJogo
.getJogadorCorrente().getSimboloDoJogador());

gradeDoJogo.setHTML(celulaSelecionada.getRowIndex(),
celulaSelecionada.getCellIndex(), simbolo);

VariaveisGlobais.statusCorrenteDoJogo.getMovimentosNoJogo()
[celulaSelecionada.getRowIndex()]
[celulaSelecionada.getCellIndex()] =
VariaveisGlobais.statusCorrenteDoJogo.getJogadorCorrente();

ChamadaParaOJulgamentoDoMovimento.verificaSeGanhou(
VariaveisGlobais.statusCorrenteDoJogo,
celulaSelecionada.getRowIndex(),
celulaSelecionada.getCellIndex());
}
}
(...)

}




E então, qual das duas opções abaixo um Stakeholder melhor entenderia? 

Os conteúdos das duas caixas abaixo foram extraídos diretamente das classes acima.
Pequenas mudanças na terminologia de um código podem causar grande impacto em sua compreensão geral.
O que pretendemos demonstrar aqui é que, assim que programadores passam a utilizar a Linguagem Ubíqua dentro de seus códigos-fonte, uma série de possibilidades, como busca e filtragens de informação, passa a ser viável e útil para aqueles que não necessariamente entendem os termos e as abreviações técnicas utilizadas nos produtos de sua empresa.


(Exemplos extraídos de um software para jogar o Jogo da Velha)

ANTES   
Mostra Cell Grid
   Exibe a string O ou X na celula do jogo.                                              

Exibe Usuario 
       
Is Vazio


DEPOIS   
Movimento do Jogador
    Efetiva o movimento do jogador na grade do jogo.

Mover 
     Quando o jogador clica numa celula na grade do tabuleiro    
     o jogo desenha um 0 ou X dependendo de qual e o 
     jogador atual.


E Celula Vazia
       Um jogador podera selecionar somente as celulas que 
       ainda nao foram selecionadas.






Utilizar a Linguagem Ubíqua dentro do código-fonte pode parecer simples, mas não é nem um pouco. Na verdade implica em uma grande quebra de paradigma para os programadores que estão acostumados a utilizar normalmente seus termos técnicos pra lá e pra cá, como exemplos "EntityBeans", "AssyncronousCalls", "DTO's", etc, etc, etc.

Substituir esses termos, que muitas vezes nem mesmo um outro programador entende facilmente, por termos que são mais auto-explicativos na visão de um Product Owner ou um Stakeholder, demanda tempo e muita refatoração por parte dos programadores. Não será de um dia para o outro que o código-fonte se transformará em ubíquo. Um progresso gradativo e contínuo deve ser o esperado.

E por falar em termo auto-explicativo, a nomenclatura ideal para ser utilizada em um código é aquela que, quando se está explicando o software para alguém, não é exigido que se diga nem mais uma palavra além da própria nomenclatura. Por exemplo, uma variável deve ser chamada "Conexao" ou "ConexaoComOBancoDeDados" ? Uma função deve ser chamada "VerificaNulo" ou "VerificaSeEmailEVazio" ?

Adoraríamos saber sua opinião. Envie-nos suas respostas sobre essas questões que estamos levantando. A equipe do Live Source agradece!!


Ubiquitous Language - Portugues
View more presentations from Alline Watkins

 Nenhum Direito Reservado. Por favor copie-nos!

No comments:

Post a Comment