A necessidade de exercícios simples

Enquanto eu passava por entrevistas de emprego, algumas empresas me pediram para fazer exercícios simples de codificação.

Como estou acostumado, resolvi esses exercícios usando uma abordagem TDD. Ao fazer isso, descobri que era uma coisa simples, mas útil de fazer para melhorar minhas habilidades ou mantê-las em boa forma.

Eu sabia que esse é o tipo de coisa de que são feitos os retiros de programação e dojos. Até agora, eu estava me perguntando o quanto eles foram úteis, agora sei que provavelmente são bastante úteis.

A experiência solo

Conforme resolvia aqueles pequenos quebra-cabeças, rapidamente entendi que era mais do que apenas escrever código. Foi a oportunidade de aprofundar o hábito de escrever software usando uma abordagem TDD com KISS e outras boas práticas.

Conselhos de diferentes autores e amigos voltaram à minha mente e rapidamente comecei a hackear.

Eu me esforcei para cortar o problema em pequenos conceitos e etapas. Em seguida, escrevi testes para cada um seguido pelo código necessário para fazer os testes passarem.
Assim que algo funcionasse, eu refatoraria o que fosse possível.

A experiência da dupla

Peguei o trem para RuLu e localizei um ex-colega meu e desenvolvedor Ruby, pois sabia que ele estava no mesmo trem. Após 2 horas de viagem e conversas, sugeri que pudéssemos fazer uma série de pequenos quebra-cabeças.

Quando ele começou a trabalhar na solução de um dos exercícios que me pediram para fazer em minhas entrevistas de emprego, fiquei surpreso ao ver uma abordagem diferente para o problema. Eu também vi o quanto eu tentaria empurrá-lo em uma direção específica, em vez de apenas observar e aprender com sua técnica diferente. Mesmo assim, não resisti em dizer a ele quando ele escreveu o código antes dos testes.

Ele também encontrou alguns bloqueios que ele estava tentando ver muito à frente (imho). Ele fazia uma longa pausa e tentava encaixar muitas funcionalidades em um único método.

Estou usando uma abordagem funcional?

Enquanto eu discutia essa história com alguns amigos da RuLu, um deles me disse que minha abordagem era bastante funcional.

Por exemplo, para implementar um compressor de string simples (‘aaaabb’ -> ‘a4b2’), eu dividiria o processo nas seguintes etapas:

  • dividir a string de entrada
  • pegue uma carta do array
  • verifique essa carta com a previamente escolhida (se houver)
  • agrupar letras idênticas
  • trocar um grupo por seu valor compactado
  • devolve o resultado ou a string original se for menor ou igual

Essa abordagem pode não produzir o algoritmo mais rápido, mas acho que ajuda a ter alta modularidade. Essa modularidade me permite manter cada método simples, o que significa que ele também pode ser testado e substituído.

Em um contexto de produto, essa abordagem agora tende a manter meu código super limpo e enxuto, ela também me força a verificar minhas classes para responsabilidade única adequada.
Por ser bastante modular e testado, também me permitirá substituir peças por módulos externos sem medo de quebrar coisas.

Isso faz sentido ? Como posso melhorar esse processo?

Mais ?

Acho que tentarei continuar fazendo esses quebra-cabeças toda semana ou algumas semanas sozinho ou com um pequeno grupo de outros desenvolvedores. Isso tem se mostrado interessante e fonte de melhorias.