Indica i criteri specifici di qualità del codice.

• Leggibilità: È facile capire cosa fa il codice. Vengono usati nomi significativi, si rispettano le convenzioni di formattazione.
• Manutenibilità: Il codice è facile da modificare e correggere errori senza introdurre nuove modifiche. Struttura modulare, bassa accoppiamento.
• Testabilità: Il codice può essere facilmente coperto da test automatici. Le funzioni e le classi hanno responsabilità chiaramente definite.
• Prestazioni: Il codice utilizza le risorse (processore, memoria, batteria) in modo efficiente. Assenza di "colli di bottiglia".
• Affidabilità: Il codice funziona in modo prevedibile ed è resistente agli errori. Gestione delle eccezioni, validazione dei dati di input.
• Riutilizzo: I componenti del codice possono essere usati in altre parti dell'applicazione o in altri progetti. Rispetto dei principi SOLID.
• Conformità agli standard di codifica: Il codice rispetta gli standard accettati nel team o nell'industria.
• Documentazione: Il codice (o API) è adeguatamente descritto, se necessario.

Esempi:

// Codice leggibile:
public void processUserData(User user) {
    if (user.isActive()) {
        // Elaborazione utente attivo
    } else {
        // Elaborazione utente inattivo
    }
}

// Codice meno leggibile:
public void procUsr(User u) {
    if (u.getStat()) { // Che cos'è getStat()?
        // codice
    } else {
        // codice
    }
}

// Codice testabile:
class UserRepository(private val apiService: ApiService) {
    fun getUserById(userId: String): User? {
        return apiService.fetchUser(userId) // La dipendenza può essere facilmente simulata per i test
    }
}

// Codice meno testabile (creazione diretta della dipendenza all'interno della funzione):
class UserRepository {
    fun getUserById(userId: String): User? {
        val apiService = ApiService() // Difficile da simulare
        return apiService.fetchUser(userId)
    }
}