O que é código genérico

Código genérico é código escrito para funcionar com vários tipos de dados ou de conteúdos, sem ter de ser reescrito para cada caso específico. Em vez de uma função só para imagens, uma só para vídeos e outra só para questionários, escreve-se uma função que serve para os três.

• Objetivo: reutilização e menos duplicação.
• Aplica-se a conteúdos digitais: uma galeria, um leitor de vídeo, um quiz interativo podem partilhar a mesma lógica de base.
• É um dos critérios de desempenho da UC: assegurar uma adaptação eficiente do código ao contexto e ao projeto.

Princípios da programação genérica

• DRY (Don't Repeat Yourself): não escrever a mesma lógica duas vezes.
• Abstração: pensar no que os conteúdos têm em comum antes de pensar nas diferenças.
• Independência de tipo: a função não deve exigir saber, à partida, se recebe uma imagem ou um vídeo.
• Baixo acoplamento: módulos que dependem pouco uns dos outros são mais fáceis de adaptar.
• Evitar complexidades desnecessárias: genérico não é sinónimo de complicado.

Classificar linguagens por paradigma

Um paradigma é uma forma de organizar o raciocínio ao escrever código:

A maioria das linguagens modernas (JavaScript, Python) combina paradigmas.

Compiladas vs interpretadas, estáticas vs dinâmicas

• Compiladas: o código é traduzido para linguagem de máquina antes de correr (C, Java parcialmente).
• Interpretadas: o código é lido e executado linha a linha em tempo de execução (JavaScript, Python).
• Tipagem estática: o tipo de cada variável é fixado e verificado antes de correr (Java, TypeScript).
• Tipagem dinâmica: o tipo é determinado em tempo de execução e pode mudar (JavaScript, Python).

Para conteúdos digitais na web, a combinação mais comum é interpretada + tipagem dinâmica: o JavaScript.

O que é um algoritmo genérico

Um algoritmo genérico resolve um problema de forma independente do tipo concreto de dado que recebe. Por exemplo, um algoritmo de ordenação que funciona tanto para números como para nomes de ficheiros.

function ordenar(lista, comparar) {
  return [...lista].sort(comparar);
}

ordenar([5, 2, 9], (a, b) => a - b);
ordenar(["zebra", "abelha"], (a, b) => a.localeCompare(b));

A função ordenar não sabe, à partida, se vai receber números ou texto: recebe também a regra de comparação.

Tipos de dados primitivos e compostos

• Primitivos: número, texto (string), booleano, null/undefined.
• Compostos: array (lista ordenada), objeto (pares chave-valor), e estruturas mais avançadas (conjuntos, mapas).
• Um algoritmo genérico costuma operar sobre dados compostos (uma coleção de conteúdos), aplicando a mesma lógica a cada elemento.
• Saber identificar o tipo de dado certo para o problema é o primeiro passo para escrever um algoritmo genérico correto.

As estruturas de dados essenciais

Cada estrutura é genérica: guarda qualquer tipo de conteúdo, desde que se respeite a mesma forma.

Escolher a estrutura certa

Exemplo: gerir uma coleção de conteúdos digitais de um curso.

const conteudos = [
  { id: 1, tipo: "imagem", titulo: "Capa" },
  { id: 2, tipo: "video",  titulo: "Introdução" },
  { id: 3, tipo: "quiz",   titulo: "Autoavaliação" },
];

const tipos = new Set(conteudos.map(c => c.tipo));

• O array guarda a coleção ordenada.
• Cada objeto guarda as propriedades de um conteúdo, genéricas para qualquer tipo.
• O Set dá, sem esforço extra, a lista de tipos sem repetições.

O que é tipagem dinâmica

Em tipagem dinâmica, o tipo de uma variável não é declarado à partida: é determinado em tempo de execução, pelo valor que ela guarda em cada momento.

let valor = 10;        // número
valor = "dez";         // agora é texto
valor = [1, 2, 3];      // agora é array

• Vantagem: flexibilidade, código mais curto, ideal para código genérico que aceita vários tipos.
• Risco: erros que só aparecem em execução (ex.: somar um número com um texto por engano).

Trabalhar com tipagem dinâmica em segurança

• Verificar o tipo com typeof antes de operar sobre um valor incerto.
• Usar valores por omissão para evitar undefined inesperado.
• Documentar, em comentário, que tipo cada função espera receber.

function mostrarConteudo(item) {
  if (typeof item !== "object" || item === null) {
    throw new Error("mostrarConteudo espera um objeto de conteúdo");
  }
  console.log(`${item.tipo}: ${item.titulo}`);
}

A tipagem dinâmica dá liberdade, mas o código genérico bem escrito verifica em vez de assumir.

Classes e objetos

Uma classe é um molde que descreve as propriedades e o comportamento comuns a um conjunto de objetos.

class ConteudoDigital {
  constructor(titulo) {
    this.titulo = titulo;
  }
  descrever() {
    return `Conteúdo: ${this.titulo}`;
  }
}

const c1 = new ConteudoDigital("Capa do curso");

• Encapsulamento: os dados (titulo) e o comportamento (descrever) vivem juntos.
• Cada new ConteudoDigital(...) cria um objeto, uma instância concreta da classe.

Herança: reaproveitar código genérico

A herança permite criar uma classe nova a partir de outra, reaproveitando o que já existe e acrescentando só o que muda.

class Imagem extends ConteudoDigital {
  constructor(titulo, url) {
    super(titulo);
    this.url = url;
  }
}

const cartaz = new Imagem("Cartaz", "cartaz.jpg");
cartaz.descrever(); // herdado de ConteudoDigital

• extends liga Imagem a ConteudoDigital.
• super(titulo) chama o construtor da classe-mãe.
• Imagem herda descrever() sem o reescrever.

O que é polimorfismo

Polimorfismo é a capacidade de objetos de classes diferentes responderem à mesma chamada de forma diferente, cada um ao seu modo.

class ConteudoDigital {
  render() { return "conteúdo genérico"; }
}
class Video extends ConteudoDigital {
  render() { return "a reproduzir vídeo"; }
}
class Quiz extends ConteudoDigital {
  render() { return "a mostrar pergunta"; }
}

Cada subclasse sobrepõe (override) o método render() com o seu comportamento próprio.

Polimorfismo em ação: percorrer sem saber o tipo

const conteudos = [new Video(), new Quiz(), new ConteudoDigital()];

for (const item of conteudos) {
  console.log(item.render());
}
// a reproduzir vídeo
// a mostrar pergunta
// conteúdo genérico

• O ciclo não sabe se cada item é vídeo, quiz ou genérico: chama sempre render().
• É isto que torna o código genérico: uma função serve para qualquer subclasse futura, sem alterações.

O que são design patterns

Um design pattern (padrão de projeto) é uma solução testada para um problema que se repete no desenho de software, com um nome e um vocabulário partilhados pelos programadores.

• Não é código pronto a copiar: é uma estrutura de raciocínio a adaptar a cada caso.
• Facilita a comunicação entre a equipa ("usa um Factory aqui").
• Ajuda a escrever código genérico, testado por milhares de projetos antes do nosso.

Categorias de design patterns

Nesta UC vemos, em detalhe, um padrão de cada categoria relevante para conteúdos digitais.

O padrão Factory

O Factory centraliza a criação de objetos numa única função, que decide qual classe instanciar com base num parâmetro.

function criarConteudo(tipo, titulo) {
  switch (tipo) {
    case "imagem": return new Imagem(titulo);
    case "video":  return new Video(titulo);
    case "quiz":   return new Quiz(titulo);
    default: throw new Error(`Tipo desconhecido: ${tipo}`);
  }
}

const item = criarConteudo("video", "Aula 1");

O resto do programa nunca escreve new Video(...) diretamente: só pede à factory.

Os padrões Strategy e Observer

Strategy: encapsula um algoritmo intercambiável, passado como parâmetro (já usámos isto na função ordenar do Bloco 3).

const estrategiaOrdenar = (a, b) => a.titulo.localeCompare(b.titulo);
conteudos.sort(estrategiaOrdenar);

Observer: um objeto (o sujeito) notifica vários observadores quando algo muda, sem os conhecer em detalhe.

document.addEventListener("conteudoTerminado", () => {
  console.log("Avançar para o próximo conteúdo");
});

Exemplo passo a passo: a classe base

Construir uma pequena biblioteca genérica para conteúdos interativos, começando pela base:

class ConteudoDigital {
  constructor(titulo, duracaoSeg = 0) {
    this.titulo = titulo;
    this.duracaoSeg = duracaoSeg;
  }
  render() {
    return `Conteúdo genérico: ${this.titulo}`;
  }
  testar() {
    return typeof this.titulo === "string" && this.titulo.length > 0;
  }
}

O método testar() é genérico: qualquer subclasse o herda sem alterações.

Exemplo passo a passo: as subclasses

class Video extends ConteudoDigital {
  render() {
    return `A reproduzir "${this.titulo}" (${this.duracaoSeg}s)`;
  }
}

class Quiz extends ConteudoDigital {
  constructor(titulo, perguntas) {
    super(titulo);
    this.perguntas = perguntas;
  }
  render() {
    return `Quiz "${this.titulo}" com ${this.perguntas.length} pergunta(s)`;
  }
}

Cada subclasse acrescenta só o que é específico; o resto vem da classe base, por herança.

Framework vs biblioteca

• Biblioteca: um conjunto de funções que o nosso código chama quando precisa (nós controlamos o fluxo).
• Framework: uma estrutura que chama o nosso código em pontos definidos (o framework controla o fluxo, o chamado "princípio de inversão de controlo").

Funcionalidades genéricas, arquitetura e extensibilidade

Um framework ou biblioteca flexível para conteúdos digitais costuma oferecer:

• Funcionalidades genéricas: carregar, mostrar e remover qualquer tipo de conteúdo.
• Arquitetura em camadas: separar dados, lógica e apresentação.
• Extensibilidade: pontos de extensão (plugins, hooks) para acrescentar tipos de conteúdo novos sem alterar o núcleo.

registarTipoDeConteudo("audio", Audio); // extensão sem tocar no núcleo

Um bom framework cresce com o projeto, sem obrigar a reescrever o que já funciona.

Práticas de adaptação do código

Adaptar código genérico é configurá-lo, não reescrevê-lo:

• Parâmetros e opções: passar valores para alterar o comportamento ({ autoplay: true }).
• Injeção de dependências: passar a função ou o objeto certo em vez de o fixar dentro do código.
• Configuração externa: um ficheiro de definições em vez de valores fixos no código (hardcoded).
• Composição: combinar peças pequenas e genéricas em vez de uma peça grande e específica.

Um código bem adaptável muda de comportamento sem ser alterado por dentro.

Exemplo: adaptar a biblioteca a um novo contexto

A mesma classe ConteudoDigital do Bloco 10, adaptada para um novo contexto (um museu virtual, em vez de um curso):

class Exponente extends ConteudoDigital {
  constructor(titulo, sala) {
    super(titulo);
    this.sala = sala;
  }
  render() {
    return `Exponente "${this.titulo}" na sala ${this.sala}`;
  }
}

Nada mudou na classe base nem no ciclo do Bloco 7: só se acrescentou uma subclasse nova. Isto é código genérico bem-sucedido.

Porque e como testar

Testar é verificar, de forma sistemática, que o código faz o que devia fazer, incluindo em casos-limite.

• Teste manual: correr o programa e observar o resultado.
• Teste automatizado: escrever código que verifica o código (mais fiável e repetível).
• Casos-limite: valores vazios, null, tipos inesperados (importante com tipagem dinâmica).

console.assert(new Video("Aula").testar() === true, "Video válido devia passar");
console.assert(new Video("").testar() === false, "Título vazio devia falhar");

Tratar erros de forma genérica

Uma função genérica deve prever que pode receber dados inesperados e reagir de forma consistente, não com um comportamento diferente por caso.

function renderSeguro(item) {
  try {
    return item.render();
  } catch (erro) {
    console.error(`Falha ao renderizar: ${erro.message}`);
    return "Conteúdo indisponível";
  }
}

try/catch isola o erro sem parar o resto do programa, um dos critérios de desempenho da UC.

Normas de segurança e saúde no trabalho

Programar é trabalho sentado, repetitivo e de ecrã: também tem normas de saúde no trabalho.

• Postura: ecrã à altura dos olhos, costas direitas, pés apoiados.
• Pausas regulares: a cada 50 a 60 minutos, levantar e descansar a vista (regra dos 20-20-20: a cada 20 min, olhar 20 segundos para algo a 20 pés/6 metros).
• Iluminação e ergonomia do posto de trabalho: evitar reflexos no ecrã, cadeira e mesa ajustadas.
• Organização do cabo e do posto, para evitar quedas e riscos elétricos.

Normas de proteção ambiental

Também o desenvolvimento de código tem impacto ambiental, direto e indireto:

• Eficiência do código: código mais eficiente consome menos energia no servidor e no dispositivo do utilizador.
• Otimizar recursos: imagens e vídeos bem dimensionados reduzem tráfego e consumo energético.
• Equipamento: prolongar a vida útil do equipamento informático; reciclar corretamente o que é descartado.
• Consumo consciente: desligar equipamento não utilizado, preferir modos de poupança de energia.

Rigor no código também é uma forma de responsabilidade ambiental.

Checklist de código genérico de qualidade

Antes de dar um módulo genérico por terminado, verificar:

• [ ] Cobre os requisitos específicos identificados no início (análise).
• [ ] Usa herança e polimorfismo onde reduz duplicação, sem forçar a árvore de classes.
• [ ] Escolheu a estrutura de dados certa para o problema.
• [ ] Trata erros de forma consistente, sem parar o programa todo.
• [ ] Foi testado, incluindo casos-limite.
• [ ] É fácil de adaptar a um contexto novo, sem alterar o núcleo.
• [ ] Não tem complexidade desnecessária.