Sou estagiário desde novembro e estou em meu primeiro emprego como desenvolvedor. Com a ajuda dos meus mentores tenho evoluído muito a cada dia, e como todos nós, desenvolvedores, percebemos um dia, notei a gritante diferença do que é aprendido na faculdade e do que é realmente usado no dia a dia do programador.

Por meio de uma capacitação gratuita de software em Maringá, participei do processo seletivo oferecido pela empresa onde trabalho e foi onde eu tive o meu primeiro contato com a programação nesse lado mais profissional. O professor já nos ensinou a importância de se ter um bom código.

Neste artigo, apresentarei conceitos simples, que os programadores mais experientes já estão cansados de saber, mas que são muito importantes para quem está entrando nessa área.

Comece a usar testes

Imagine você comprar um carro que não foi testado nenhuma vez em sua etapa de produção. Nem motor, nem câmbio, e nem mesmo as rodas. Qual confiança você terá nesse automóvel? Claro que nada garante que ele não irá funcionar, mas caso não funcione, você não ficará nada feliz.

Assim também é no mundo da programação. Um código sem teste não terá muita credibilidade do cliente. Claro que para isso temos nossa equipe de testes, mas podemos ajudá-la com a criação de testes unitários.

Teste unitário é uma das formas de teste que se trata da validação do comportamento de trechos do seu código. Essa validação é criada pelo desenvolvedor, usando sua criatividade para conseguir testar as partes mais importantes do seu projeto. Testando o código, o programador garante que as partes do código testadas funcionam. Dessa forma, garante também a confiabilidade do código, e maior facilitação do trabalho da equipe de testes.

Portanto, como consequência dessa cultura de testes, conheci o TDD (Test-Driven Development). Essa técnica orienta seu desenvolvimento a ter pequenas entregas, alto feedback do comportamento e consequentemente cobertura de testes (que também servem como documentação em alguma medida).

Essa prática consiste em dividir o trabalho em pequenas etapas (prática também conhecida como baby steps). Escreva um teste que estimule um comportamento, implemente a funcionalidade e assim que estiver OK, vá para a próxima etapa.

Para mim, o TDD foi muito útil para a quebra de complexidade do código. Percebi também que não é necessário seguir ao pé da letra essa ordem. Começar a desenvolver um problema é complexo, fica bem mais fácil abstrair, dividindo-o em pequenas partes, não precisando construir todo aquele monstro de uma vez.

Me refiro ao termo cultura ao falar de testes unitários, pois eles devem se tornar um hábito para o programador, e não apenas uma prática obrigatória, dando mais naturalidade ao seu desenvolvimento.

• Veja aqui um estudo mais aprofundado sobre esse tema

Não reinvente a roda

Um ditado bem enfatizado no meio da programação, é: “não reinvente a roda”. Ou seja, não seja redundante ao escrever seu código. Ao pensar em um problema, certifique-se de que alguém já não tenha tido esse problema antes de você (e acredite, isso acontecerá na maioria dos casos).

Com uma simples pesquisa no Google podemos resolver esse tipo de problema, conhecendo várias bibliotecas nativas das linguagens de programação (como, por exemplo, a biblioteca stream de Java, que auxilia muito no uso de listas).

Com essas pesquisas adquirimos mais ferramentas e ideias para poder usar em problemas posteriores, aumentando nossa experiência em programação.

O que me ajudou muito foi aprender a fazer pesquisas dos meus problemas em inglês. Isso aumenta o leque de dicas e materiais disponíveis, portanto, uma dica que deixo é exercitar essa prática, pois pesquisas apenas em português são limitadas.

Pratique o reuso

Em uma empresa que trabalha com milhares de linhas de código, executando vários serviços simultaneamente, cada linha de código a mais se torna muito cara. Por isso, deve sempre se programar visando o reuso.

Há vários modos de reuso na programação, como os explícitos nas linguagens de programação, por exemplo: herança e interface. Além desses, outras formas, como a identificação de números mágicos, e também métodos com responsabilidade única.

package exemplosartigo;

public class ExemploSelic1 {

	public Double lucroSelic(Double saldo) {
		return saldo * 0.065;
	}
}

Podemos ver um exemplo de número mágico acima. O que seria esse 0.065? No caso, é a taxa selic, que multiplicada com a quantidade de seu investimento, retorna o lucro adquirido. Mas o próximo programador que ver seu código pode não saber disso. Portanto, uma dica importante é extraí-lo para uma constante, como no exemplo abaixo:

package exemplosartigo;

public class ExemploSelic2 {

	private static final double VALOR_SELIC = 0.065;

	public Double lucroSelic(Double saldo) {
		return saldo * VALOR_SELIC;
	}
}

Assim, o próximo programador que vir seu código, entenderá de onde vem esse valor, além de poder usá-lo em outras partes do programa, ocupando menos espaço na memória, pois não precisará declarar o valor outra vez.

package exemplosartigo;

public class ExemploString1 {

	public String deixarMaiusculoEretirarPrimeiraLetra(String palavra) {

		palavra = palavra.toUpperCase();

		palavra = palavra.substring(1);

		return palavra;
	}
}

No código acima temos um exemplo de uma função com várias responsabilidades. Outra forma de reuso na programação é cada método ter apenas uma responsabilidade, ou seja, fazer apenas uma coisa – também conhecido como responsabilidade única.

Responsabilidade única é um dos cinco princípios SOLID. São princípios identificados por Robert C. Martin e destinados a fazer projetos de software mais compreensíveis, flexíveis e de fácil manutenção.

Veja aqui um vídeo de aula SOLID.

package exemplosartigo;

public class ExemploString2 {

	public String retirarPrimeiraLetra(String palavra) {
		return palavra.substring(1);
	}

	public String deixarMaiusculo(String palavra) {
		return palavra.toUpperCase();
	}
}

Claro que isso é apenas um simples exemplo, mas em um código maior, essa prática pode aumentar muito a legibilidade e as chances de reuso. Um dos passos a seguir para começar essa refatoração seria identificar os códigos duplicados e os isolar em métodos, criando uma generalização – podendo assim reusá-los futuramente.

Existem nas IDEs, como Eclipse e NetBeans, atalhos para extrair códigos para métodos, variáveis, e constantes, facilitando esse processo.

Conclusão

Portanto, sempre se preocupe com seu código, aplicando esses e outros conceitos que deixam seus projetos mais organizados e melhoram a arquitetura do seu projeto, facilitando a manutenção posteriormente.