Definire l'interfaccia Semplicità vs Implementazione Semplicità

What does he mean by interface and implementation and what does simplicity mean for each of them?

Non pensarci troppo, è solo inglese.

Intende l'interfaccia del tuo codice (non necessariamente interfaces !) - come le persone lavorano con il tuo codice. E l'implementazione del tuo codice del tuo codice - in che modo il tuo codice fa effettivamente le cose che deve fare. E semplice è semplice - le tue cose sono facili da usare.

La semplicità nell'interfaccia significa che è facile usare le tue cose. Le tue funzioni hanno nomi validi con parametri ovvi e pochi effetti collaterali? Fanno ciò di cui i tuoi utenti hanno bisogno? Le tue classi hanno nomi validi con funzionalità ovvia? Fanno ciò di cui i tuoi utenti hanno bisogno? Senza troppi problemi?

Semplicità nell'implementazione significa che è facile per i programmatori (o per te) lavorare con i tuoi contenuti. Puoi modificare facilmente il codice? Puoi testarlo facilmente? Riesci a capirlo? Eseguire il debug?

Mentre la semplice implementazione spesso offre un'interfaccia semplice, non è sempre il caso. Alcuni dei migliori progetti isolano bit di un'implementazione necessariamente complessa dietro una semplice interfaccia. Allo stesso modo, se l'implementazione più semplice non è ciò di cui i tuoi utenti hanno bisogno, puoi ritrovarti con un'interfaccia complessa.

Sembra che la pagina stia usando quei termini letteralmente, senza riferimento a nessun particolare costrutto di programmazione, quindi non c'è davvero nulla da definire. Invece proverò a dare un esempio.

Dì che hai una classe che ottiene cose da Internet. Ecco una semplice versione dell'interfaccia:

class Internet {
    int sendRequest(const std::string& url, std::string& response);
}

Internet::sendRequest(const std::string& url, std::string& response) {
    // parse the url into its various tokens
    m_protocol = /* first token, or https if not provided */
    m_domain = /* second token */
    while(...) { m_parameters.push_back(/* another token */); }
    ...
    switch(m_protocol) {
        case HTTPS: HTTPSImpl.request(m_domain, ...); break;
        ...
    }
}

Ecco una versione di implementazione semplice:

class Internet {
    int setProtocol(Internet::Protocol protocol);
    int setDomain(const std::string& domain);
    int addParameter(...);
    ...
    int sendRequest(std::string& response);
}

Internet::request(std::string& response) {
    switch(protocol) {
        case HTTPS: HTTPSImpl.request(m_domain, ...); break;
        ...
    }
}

Essenzialmente è un compromesso tra il fare in modo che l'implementatore si occupi della complessità rispetto all'interfaccia utente. La maggior parte delle volte verrai (giustamente) detto che nascondere la complessità dell'utente è una buona cosa, ma la pagina di Richard Gabriel sostiene che potrebbe non essere sempre così.