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

"We understand each other"  (James Shore)

http://jamesshore.com/Agile-Book/ubiquitous_language.html

• 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 e 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 e 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(grid, cell)) {  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 gradeDoJogo, Cell 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!

O problema da comunicação no ambiente de desenvolvimento de software

Comunicação ineficaz é reconhecidamente o ponto fraco de vários projetos de desenvolvimento de software. As causas podem ser diversas e as conseqüências catastróficas. Identificar o desejo de um usuário de software, encaixar esse desejo dentro do que uma empresa de desenvolvimento pode financiar e ater-se ao que é tecnicamente possível de ser construído em um tempo hábil envolve tantos perfis de profissionais diferentes que tudo isso raramente se transforma em um pacote bem sucedido de software.

Analisando mais profundamente as causas dessa deficiência na comunicação, identificamos que duas das grandes ramificações do problema encontram-se na interação entre o cliente e os seus usuários e na interação entre os stakeholders e os desenvolvedores.

A comunicação entre o cliente que está pagamento pelo desenvolvimento do software e os usuários que de fato o utilizarão vem sendo amplamente estudada pelo Desenvolvimento Lean, com resultados práticos e extremamente eficazes para quem está de fato disposto a minimizar o problema (Product-Market Fit, Minimum Viable Product, Código Magro, ...). Nenhuma solução mágica ainda foi encontrada, mas compreende-se que o trabalho deve ser em conjunto, com a participação direta, irrestrita e o mais antecipadamente possível dos usuários finais no processo de desenvolvimento do software. Saiba mais sobre Lean Development em: http://en.wikipedia.org/wiki/Lean_software_development  ou sobre Lean Startups em: http://www.startuplessonslearned.com/

O outro ramo do problema da comunicação na construção de um software encontra-se no abismo que grande parte dos projetos criam entre desenvolvedores e stakeholders (gerentes de projeto, diretores da empresa, especialistas de negócios, ...). Para quem já passou anos e anos vivenciando ambos os lados desse abismo, não é difícil de visualizar o gigantesco conflito de interesses que a maioria das empresas de desenvolvimento acaba gerando dentro de seu próprio ventre. E quando interesses estão em conflito, informação passa a significar fonte de poder, afetando diretamente a transparência e a eficácia das comunicações.

Quantos programadores já não ouviram de seus gerentes a irritante frase: "Para quê você quer saber isso?"?

Quantos stakeholders já não visualizaram diagramas de desenvolvimento totalmente nebulosos que começam com a "Gang of Four" e terminam sem nenhuma terminologia que se faça compreender?

O ambiente de desenvolvimento de software tradicional é em geral estritamente hierárquico, com uma pirâmide decisória que tem em seu topo os diretores da empresa e os gerentes de projeto e em sua base os líderes de desenvolvimento, os programadores, os testers e por último os usuários. Quando uma turbulência acontece, essa hierarquia gera uma cadeia de acusações que faz com que os que estão na base da pirâmide se sintam extremamente prejudicados e incompreendidos. Proteger-se atrás de uma linguagem altamente técnica e obtusa é uma conseqüência natural para um programador em um ambiente como esse.

Dentro do enorme fracasso que o desenvolvimento de software tradicional tem apresentado, o ambiente Ágil e Lean vem retornando a esperança àqueles que querem ver seus softwares funcionando na vida real e que não se enquadram tão bem nesse ambiente de egos inflados e "salve seu emprego quem puder". 

Percebemos que o Grau de Transparência na comunicação da equipe de desenvolvimento pode ser também uma medida para o quão Ágil esse time vem sendo. Transparência é chave para a maioria dos valores da eXtreme Programming (como respeito, coragem, comunicação e feedback). 

Mas infelizmente, ser Ágil não vem sendo o suficiente para conseguir comunicar-se com eficiência. Mesmo entendendo a importância das práticas ágeis e desejando ser totalmente transparente na comunicação, muitos desenvolvedores, product owners e stakeholders ainda encontram uma enorme dificuldade para comunicar-se uns com os outros. Apesar das várias referências ao assunto, o problema da comunicação ainda persiste generalizadamente e propostas de soluções práticas ainda se fazem necessárias e urgentes.

Ao tentar encontrar soluções reais para o problema, percebemos que uma das causas dessa dificuldade pode-se dizer que está nas diferenças inerentes às linguagens que ambos product owners e desenvolvedores estão acostumados a utilizar em seu dia-a-dia. Descobrimos então que a difusão plena de uma Linguagem Ubíqua é um dos caminhos a serem seguidos. Linguagem Ubíqua é aquela linguagem única e comum, encontrada entre o domínio de negócios e os jargões técnicos dos desenvolvedores, e que é criada e compartilhada pela equipe de software durante o processo de desenvolvimento. Saiba mais sobre Linguagem Ubíqua em:  http://jamesshore.com/Agile-Book/ubiquitous_language.html

A solução que oferecemos aqui constitui em aplicar a Linguagem Ubíqua inclusive no nível mais técnico do desenvolvimento de software que é o seu próprio código-fonte, e então utilizar esse código otimizado como base para várias outras atividades como comunicação, planejamento, documentação e medição. 

Apesar da resistência à desmistificação do código fonte que encontramos em nossos experimentos, ainda assim evidenciamos claramente o aumento significativo na confiança que o diálogo franco e aberto em frente à realidade crua do código fonte traz para toda a equipe ágil, impossibilitando a criação de subsídios de defesa como documentações paralelas que raramente estão atualizadas e que geralmente são utilizadas para mascarar a situação atual do desenvolvimento.

Para fazer uso na prática dessa solução, desenvolvemos uma ferramenta web de fácil utilização como um meio auxiliar à comunicação entre profissionais técnicos e não-técnicos do desenvolvimento de software, expondo abertamente para todos da equipe o código-fonte da aplicação, evidenciando ainda mais a necessidade da Linguagem Ubíqua e promovendo a disseminação irrestrita das informações importantes do processo de desenvolvimento do software.

Por sabermos que o código-fonte propriamente dito não é uma informação compreensível a todos, desenvolvemos também uma funcionalidade que extrai a estrutura e os aspectos de negócio de dentro do código-fonte e os expõe claramente, facilitando a compreensão até mesmo para quem não é especialista em programação.

Resumidamente, nossa ferramenta fornece aos product owners e stakeholders uma janela esclarecedora e não intimidativa para dentro do código-fonte da aplicação e uma via auxiliar de interação para que os profissionais não-técnicos também possam participar da programação em pares. 

 Nenhum Direito Reservado. Por favor copie-nos!