Se você quer se destacar e construir algo de valor para as pessoas, é hora de mergulhar nesses princípios. Vamos juntos?

O valor de conhecer os princípios fundamentais

Agora, sem mais delongas, vamos direto ao ponto: os 5 princípios essenciais que todo dev precisa dominar.

1. KISS (Keep it simple, stupid)

Evite o "código Frankenstein"

Exemplo prático:

// Código complexo
function processarInscricao(aluno, curso, desconto) {
  if (aluno.vip && desconto > 0) {
    // Aplica desconto
  }
  // Processa a inscrição
  // Envia e-mail de confirmação
  // Atualiza o número de vagas do curso
}

// Código simplificado usando funções menores e mais claras
function aplicarDesconto(aluno, desconto) {
  if (aluno.vip && desconto > 0) {
    // Aplica desconto
  }
}

function processarInscricao(curso) {
  // Processa a inscrição no curso
}

function enviarConfirmacao(aluno) {
  // Envia e-mail de confirmação para o aluno
}

function atualizarVagas(curso) {
  // Atualiza o número de vagas disponíveis no curso
}

Viu como ficou mais simples e eficiente? Seguindo o KISS, você constrói um código que cresce junto com o projeto, sem se tornar um obstáculo.

2. DRY (Don't repeat yourself)

Exemplo prático:

// Código duplicado
function exibirErroDePagamento() {
  console.log('Erro ao processar pagamento na formação fullstack.');
}

function exibirErroDeFormulario() {
  console.log('Erro ao enviar o formulário de inscrição.');
}

// Aplicando DRY
function exibirMensagemDeErro(mensagem) {
  console.log(mensagem);
}

exibirMensagemDeErro('Erro ao processar pagamento na formação fullstack.');
exibirMensagemDeErro('Erro ao enviar o formulário de inscrição.');

Com o DRY, você centraliza a lógica do seu código, economiza tempo e evita aquele caos de ter código duplicado por todo lado. E aí, na próxima vez que precisar fazer uma alteração, é só ajustar em um único lugar e pronto!

3. Falhe rápido

Exemplo prático:

function processarInscricao() {
  validarDadosAluno();
  confirmarPagamento();
  enviarEmailConfirmacao();
}

function validarDadosAluno() {
  if (!dadosAluno.saoValidos) throw new Error("Dados do aluno inválidos");
}

function confirmarPagamento() {
  if (!pagamento.autorizado) throw new Error("Pagamento não autorizado");
}

function enviarEmailConfirmacao() {
  // Envia o e-mail de confirmação
}

Isso não só ajuda a encontrar os bugs mais rápido, como também te dá muito mais controle e clareza sobre cada etapa do processo. É como ter um superpoder de depuração!

4. Composição sobre herança

Trade-offs entre composição e herança:

• Herança:
• Benefícios:
• Reutilização de código comum entre classes.
• Estrutura hierárquica clara quando há uma relação "é um".
• Limitações:
• Pode levar a hierarquias rígidas e difíceis de modificar.
• Dificulta a mudança de comportamento em tempo de execução.

• Composição:
• Benefícios:
• Maior flexibilidade ao combinar comportamentos.
• Facilita a manutenção e extensão do código.
• Limitações:
• Pode exigir mais código para delegar funcionalidades.
• Requer um design cuidadoso pra evitar acoplamentos desnecessários.

Exemplo prático:

// Usando herança
class Curso {
  iniciar() {
    console.log("Curso iniciado!");
  }
}

class CursoOnline extends Curso {
  emitirCertificado() {
    console.log("Certificado emitido.");
  }
}

const cursoReact = new CursoOnline();
cursoReact.iniciar();
cursoReact.emitirCertificado();

Aqui, a herança faz sentido porque um CursoOnline é um Curso, e estamos reutilizando o método iniciar.

// Usando composição
class Curso {
  constructor(nome, certificacao) {
    this.nome = nome;
    this.certificacao = certificacao;
  }

  iniciar() {
    console.log(`${this.nome} iniciado!`);
  }

  emitirCertificado() {
    if (this.certificacao) {
      this.certificacao.emitir(this);
    } else {
      console.log("Este curso não oferece certificação.");
    }
  }
}

class Certificacao {
  emitir(curso) {
    console.log(`Certificado do curso de ${curso.nome} emitido.`);
  }
}

const certificacao = new Certificacao();
const cursoReact = new Curso("React", certificacao);
const cursoGit = new Curso("Git", null);

cursoReact.iniciar();
cursoReact.emitirCertificado();

cursoGit.iniciar();
cursoGit.emitirCertificado();

Aqui, usamos composição pra adicionar a funcionalidade de certificação apenas aos cursos que oferecem esse recurso. Isso deixa o código mais flexível e fácil de manter.

5. Não otimize prematuramente

Exemplo prático:

// Tentativa de otimização prematura
function calcularTotal(itens) {
  let total = 0;
  for (let i = 0, len = itens.length; i < len; i++) {
    const item = itens[i];
    total += item.preco * (1 - (item.desconto || 0) / 100);
  }
  return parseFloat(total.toFixed(2));
}

Ficou bem complexo, né? Você tentou otimizar usando um loop tradicional e operações matemáticas pra ganhar microsegundos, mas será que precisava disso tudo agora? Além de ser mais difícil de entender, fica mais trabalhoso de manter.

// Código simples e claro
function calcularTotal(itens) {
  return itens.reduce((total, item) => {
    const precoComDesconto = item.preco - (item.preco * (item.desconto || 0)) / 100;
    return total + precoComDesconto;
  }, 0);
}

Percebeu? Mantivemos a funcionalidade de calcular o total com descontos de forma simples e direta. O código está claro e faz o que precisa. Se lá na frente a performance virar um problema, aí sim a gente pensa em otimizações.

Conclusão:

Qual desses princípios você vai aplicar primeiro no seu próximo projeto? Vamos juntos construir um código cada vez mais limpo e eficiente!