Cosa sono la coesione e l'accoppiamento nella…

Cohesion (Cohesion) è una misura di quanto strettamente gli elementi all'interno di un modulo (classe, funzione) siano collegati. Una alta coesione significa che gli elementi del modulo sono focalizzati sull'esecuzione di un singolo compito o concetto. Un modulo ben progettato ha una alta coesione.

Esempi di livelli di coesione (da bassa a alta):

Casuale (Coincidental): Gli elementi sono collegati casualmente, senza un legame logico.
Logico (Logical): Gli elementi eseguono una serie di azioni logicamente correlate, ma la selezione viene fatta da codice esterno.
Temporale (Temporal): Gli elementi sono collegati dal fatto di essere eseguiti nello stesso momento.
Procedurale (Procedural): Gli elementi seguono una procedura di esecuzione.
Comunication (Communicational): Gli elementi lavorano con gli stessi dati.
Sequenziale (Sequential): L'output di un elemento è l'input di un altro.
Funzionale (Functional): Tutti gli elementi contribuiscono all'esecuzione di una funzione chiaramente definita.

Il coupling (Coupling) è una misura di dipendenza tra diversi moduli. Un basso coupling significa che i moduli sono relativamente indipendenti tra loro. Ridurre il coupling rende il sistema più flessibile, manutenibile e testabile.

Esempi di livelli di coupling (da alto a basso):

Contenuto (Content): Un modulo accede direttamente ai dati interni o all'implementazione di un altro modulo.
Comune (Common): I moduli usano un'area di dati globale condivisa.
Controllo (Control): Un modulo passa una bandiera di controllo che determina il comportamento di un altro modulo.
Stampo (Stamp): Trasferimento di dati composti (oggetti, strutture), ma il modulo usa solo una parte di essi.
Dati (Data): Trasferimento di dati semplici come parametri.
Messaggi (Message): I moduli scambiano messaggi (ad esempio, tramite eventi, interfacce). Questa è la forma più debole di coupling.

L'obiettivo di un buon design: alta coesione (all'interno dei moduli) e basso coupling (tra i moduli).

<?php

// Esempio di alta coesione (Cohesion funzionale)
// Questa classe si concentra solo sulla gestione degli utenti
class UserManager {
    private array $users = [];

    public function addUser(string $name): void {
        $this->users[] = $name;
    }

    public function getUsers(): array {
        return $this->users;
    }

    public function deleteUser(string $name): void {
        $this->users = array_filter($this->users, fn($user) => $user !== $name);
    }
}

// Esempio di basso coupling (Coupling dei dati)
// 'processOrder' dipende solo dai dati passati ($orderId, $amount)
class OrderProcessor {
    public function processOrder(int $orderId, float $amount): bool {
        // Logica di elaborazione dell'ordine...
        // Non dipende direttamente dall'implementazione di altre classi,
        // solo dai dati di input.
        echo "Elaborazione ordine ID $orderId con importo $amount\n";
        return true;
    }
}

// Esempio in cui UserManager e OrderProcessor non hanno una forte dipendenza tra loro.
// Possono essere usati indipendentemente o insieme, ma le loro modifiche interne
// non influenzano molto l'uno sull'altro.

?>

Cosa sono la coesione e l'accoppiamento nella programmazione?