UI2Code

Princípios KISS, YAGNI e DRY

Imagem para Princípios KISS, YAGNI e DRY

It managementPostado em  Atualizado em  5 min de leitura

Olá, Perfil !!!

Os princípios KISS, YAGNI e DRY são fundamentais para ajudar os desenvolvedores a criar código limpo, eficiente e fácil de manter.

O princípio KISS sugere que a solução mais simples é frequentemente a melhor. Isso significa que os desenvolvedores devem buscar manter as coisas simples e diretas sempre que possível, evitando a complexidade desnecessária que pode dificultar a manutenção e o entendimento do código.

O princípio YAGNI, por sua vez, incentiva a criação apenas das funcionalidades necessárias no momento presente. Isso evita a criação de recursos que podem nunca ser utilizados, economizando tempo e recursos valiosos.

Já o princípio DRY sugere que as informações no código devem ser armazenadas em um único local e que cada parte do código deve ter uma única fonte de verdade. Isso evita a duplicação de código e a inconsistência de informações, facilitando a manutenção e evolução do código ao longo do tempo.

KISS - Keep it simple, stupid

O princípio KISS ("Keep It Simple, Stupid", ou "Mantenha Simples, Estúpido") é um princípio de design que prega que a solução mais simples costuma ser a melhor. Ele pode ser aplicado em diversas áreas, desde a criação de produtos até a programação de computadores e gestão de projetos.

O princípio KISS parte da ideia de que a simplicidade é a chave para soluções eficazes e eficientes. Soluções complexas são difíceis de entender, implementar e manter, enquanto soluções simples são mais fáceis de entender e utilizar.

No entanto, é importante ressaltar que simplicidade não significa simplismo ou superficialidade. Uma solução simples pode ser elegante, robusta e sofisticada, desde que não seja acrescida de elementos desnecessários que possam prejudicar sua eficácia e eficiência.

Em síntese, o princípio KISS prega que devemos manter as soluções o mais simples possível, eliminando tudo que for desnecessário e mantendo apenas as funcionalidades essenciais. Dessa forma, é possível criar soluções eficazes, eficientes e de qualidade.

// Exemplo não KISS
function calculateAverage(numberList) {
  let total = 0
  for (let i = 0; i < numberList.length; i++) {
    total += numberList[i]
  }
  return total / numberList.length
}

// Exemplo KISS
function calculateAverage(numberList) {
  const sum = numberList.reduce((total, num) => total + num)
  return sum / numberList.length
}

A função calculateAverage foi simplificada usando o método reduce() em vez de usar um for para somar os elementos da lista. Isso torna o código mais simples e fácil de entender.

YAGNI - You Aren't Gonna Need It

O princípio YAGNI ("Você Não Vai Precisar Disso") é uma filosofia que preconiza que não devemos adicionar funcionalidades que não são estritamente necessárias no momento presente. O objetivo é evitar a complexidade desnecessária e o desperdício de tempo e recursos na criação de recursos que podem nunca ser utilizados.

Seguindo o princípio YAGNI, os desenvolvedores devem se concentrar nas funcionalidades essenciais e evitar adicionar recursos adicionais que podem ser úteis no futuro, mas que não são necessários no momento. Esses recursos extras podem incluir código redundante, bibliotecas desnecessárias ou recursos de interface de usuário que não são críticos para a funcionalidade principal.

// Exemplo não YAGNI
function calculateAverage(numbersList) {
  if (numbersList.length > 0) {
    let total = 0
    for (let i = 0; i < numbersList.length; i++) {
      total += numbersList[i]
    }
    return total / numbersList.length
  } else {
    return 0
  }
}

// Exemplo YAGNI
function calculateAverage(numbersList) {
  if (numbersList.length > 0) {
    const sum = numbersList.reduce((total, num) => total + num)
    return sum / numbersList.length
  }
  return 0
}

A função calculateAverage foi simplificada, removendo o código desnecessário que tratava o caso em que a lista de números estivesse vazia. Isso reduz a complexidade e torna o código mais fácil de ler.

DRY - Don't repeat yourself

O princípio DRY ("Don't Repeat Yourself", ou "Não Se Repita") é um princípio que sugere que as informações no código devem ser armazenadas em um único local e que cada parte do código deve ter uma única fonte de verdade. O objetivo do princípio DRY é reduzir a duplicação de código e evitar a inconsistência de informações, o que pode levar a problemas de manutenção e a bugs no software.

Seguindo o princípio, os desenvolvedores devem evitar copiar e colar código sem modificá-lo. Em vez disso, eles devem criar funções, classes ou bibliotecas reutilizáveis em todo o código. Isso torna o código mais fácil de manter e atualizar, já que as mudanças precisam ser feitas em apenas um lugar. Adicionalmente, ao evitar a duplicação de código, o tamanho do código é reduzido, tornando-o mais fácil de ler e entender.

// Exemplo não DRY
function sum(a, b) {
  console.log(`A soma de ${a} e ${b} é ${a + b}`)
}

function subtract(a, b) {
  console.log(`A subtração de ${a} e ${b} é ${a - b}`)
}

function multiply(a, b) {
  console.log(`A multiplicação de ${a} e ${b} é ${a * b}`)
}

function divide(a, b) {
  console.log(`A divisão de ${a} e ${b} é ${a / b}`)
}

// Exemplo DRY
function operate(a, b, operator) {
  let result
  switch (operator) {
    case '+':
      result = sum(a, b)
      break
    case '-':
      result = subtract(a, b)
      break
    case '*':
      result = multiply(a, b)
      break
    case '/':
      result = divide(a, b)
      break
    default:
      console.log('Operador inválido')
      return
  }
  console.log(`O resultado da operação ${operator} entre ${a} e ${b} é ${result}`)
}

A função operate foi criada para evitar a duplicação de código que estava presente nas funções de sum, subtract, multiply e divide. Ao passar um operador para a função operate, é possível realizar qualquer uma dessas operações.

Conclusão

Esses princípios são fundamentais para ajudar os desenvolvedores a escrever código mais legível, organizado e compreensível, o que resulta em software mais eficiente e fácil de manter ao longo do tempo. Quando aplicados corretamente, esses princípios podem melhorar significativamente a qualidade do código e reduzir a incidência de bugs e problemas de manutenção. Além disso, um código claro e limpo também facilita a colaboração entre os membros da equipe e pode tornar a introdução de novos desenvolvedores ao projeto muito mais fácil.

Referências

UI2Code

Autor

Hemerson Vianna

github: ui2code

twitter: ui2code

Artigos relacionados