Sto ponendo questa domanda ai programmatori C ++ perché: a) Solo un programmatore C ++ può giudicare i meriti tecnici degli esempi; b) Solo un programmatore avrà un'idea del temperamento di un altro programmatore che scrive codice come questo.
Le risorse umane e i direttori sono consapevoli che esiste un problema semplicemente perché vedono prove sul campo. È mia decisione se diamo al programmatore in questione più tempo. Molti degli errori sono a un livello molto elementare - la mia domanda (ai programmatori) è se qualcuno che professa di essere uno sviluppatore C ++ senior debba beneficiare di un dubbio basato su esempi del loro codice attuale. I non programmatori - anche le persone al di fuori della programmazione C ++ - non possono esprimere alcun giudizio al riguardo.
Per lo sfondo, mi è stato assegnato il compito di gestire gli sviluppatori per un'azienda ben consolidata. Hanno un singolo sviluppatore specializzato in tutta la loro codifica C ++ (da sempre), ma la qualità del lavoro è spaventosa. Revisioni e test del codice hanno rivelato molti problemi, uno dei peggiori sono le perdite di memoria. Lo sviluppatore non ha mai testato la presenza di perdite nel suo codice e ho scoperto che le applicazioni potevano perdere molti MB con un solo minuto di utilizzo. L'utente stava segnalando enormi rallentamenti e la sua opinione era "non ha niente a che fare con me - se si chiudono e si riavviano, tutto va di nuovo bene".
Gli ho dato gli strumenti per rilevare e rintracciare le perdite e mi sono seduto con lui per molte ore per dimostrare come vengono utilizzati gli strumenti, dove si verificano i problemi e cosa fare per risolverli. Siamo in ritardo di 6 mesi e gli ho assegnato di scrivere un nuovo modulo. L'ho esaminato prima che fosse integrato nella nostra base di codice più ampia, e sono rimasto sgomento per scoprire la stessa codifica errata di prima. La parte che trovo incomprensibile è che parte della codifica è peggiore di quella amatoriale. Ad esempio, voleva una classe (Foo) che potesse popolare un oggetto di un'altra classe (Bar). Decise che Foo avrebbe tenuto un riferimento a Bar, ad esempio:
class Foo {
public:
Foo(Bar& bar) : m_bar(bar) {}
private:
Bar& m_bar;
};Ma (per altri motivi) aveva anche bisogno di un costruttore predefinito per Foo e, piuttosto che mettere in discussione il suo progetto iniziale, scrisse questo gioiello:
Foo::Foo() : m_bar(*(new Bar)) {}Pertanto, ogni volta che viene chiamato il costruttore predefinito, viene trapelata una barra. A peggiorare le cose, Foo alloca memoria dall'heap per altri 2 oggetti, ma non ha scritto un distruttore o un costruttore di copie. Quindi ogni allocazione di Foo in realtà perde 3 oggetti diversi e puoi immaginare cosa è successo quando un Foo è stato copiato. E - va solo meglio - ha ripetuto lo stesso schema su altre tre classi, quindi non è una scivolata una tantum. L'intero concetto è sbagliato su così tanti livelli.
Mi sentirei più comprensivo se questo provenisse da un principiante totale. Ma questo ragazzo lo fa da molti anni e negli ultimi mesi ha avuto una formazione e una consulenza molto focalizzate. Mi rendo conto che per la maggior parte del tempo ha lavorato senza tutoraggio o recensioni tra pari, ma sto iniziando a sentire che non può cambiare. Quindi la mia domanda è: continueresti con qualcuno che sta scrivendo un codice così evidentemente cattivo?