Koodiarvostelut: Äärimmäisten rikkomusten yleiset lähteet ja niiden välttämiseen liittyvien väitteiden välttäminen

Veitset piirretään. Terät teroitetaan konfliktien vuoksi. Kehittäjien välillä käy riita. Kooderien intohimoja ei tule bugisen ohjelmiston päälle, vaan hiukan tiiviin tai sanallisen koodin yli. Nuo linjat ovat merkkejä hakkeroinnista. Jokainen ohjelmoija, joka on eri mieltä, on amatööri. Vain neofyytti tuottaisi menetelmiä ja lohkoja, jotka loukkaavat selvästi hyvää makua. Erilaiset mieltymykset, eivät luonnonlakit, ovat kuitenkin tämän konfliktin ja vitriolin lähde. Kehittäjien välinen viha on tässä tapauksessa seurausta erilaisista taipumista kaupan tiivisyyteen eri päämääriä varten. Nämä tavoitteet ja taipumus niihin ovat erilaisia ​​jokaisella kehittäjällä, mikä johtaa jatkuviin konflikteihin tietyillä alueilla. Yksi sellainen paikka on sanallinen tai pithy-koodi. Taistelujen minimoimiseksi joukkue voi käyttää koodiarviointeja korostamaan kaikkein räikeimmät segmentit, ja ryhmä voi kiistellä kyseisistä osista sen sijaan, että kiistelisi jokaisen koodikannan rivin ja lohkon yli.

Tietyt koodirakenteet tai tekniikat todennäköisesti tuottavat äärimmäiset rikkomukset ja johtavat argumentteja näiden rikkomusten korjaamiseksi. Näiden väärinkäytösten korjaaminen johtaa intensiivisiin väitteisiin. Nämä erimielisyydet voidaan ratkaista tai ainakin poistaa niiden käytöstä alla lueteltujen erityisten kielellisten piirteiden ja tekniikoiden suhteen.

Ehdollinen operaattori vs. lause

Kielelliset elementit, ehdollinen operaattori ja if-lause, johtavat argumentteihin, joissa eri leirit väittävät, että kukin niistä on ylivoimainen tekniikka tietyille operaatioille. Nämä toimet voidaan toteuttaa lukemattomilla tavoilla, jokaisella tekniikalla on etuja ja haittoja.

Jos lause: If-lause voi vaikuttaa hirvittävän laajaan koodiin, kun olosuhteiden tiheys on korkea. Suuri tiheys tekee lohkosta tai menetelmästä turvonneen. Jos if-lauseilla kirjoitettu koodi on silti myös erittäin vianetsyttävä, koska kehittäjä voi käydä läpi jokaisen rivin.

jos (label1IsRequired) {
 label1.Color = “punainen”;
} muuta {
 label1.Color = “musta”;
}
jos (label2IsRequired) {
 label2.Color = “punainen”;
} muuta {
 label2.Color = “musta”;
}
jos (label3IsRequired) {
 etiketti3.väri = “punainen”;
} muuta {
 etiketti3.väri = “musta”;
}

Ehdollinen operaattori: Ehdollinen operaattori voi johtaa joihinkin räikeästi katkoviivoihin, kun sitä käytetään korvaamaan useita if-lauseita. Sulautetut ehdolliset operaattorit tekevät koodista äärimmäisyyteen vietämisen yhteydessä erittäin vaikeaa lukea, testata tai korjata. Mikä tahansa ehdollisille operaattoreille raskas lohko tai menetelmä on myös erittäin kompakti, mikä vähentää koodin määrää, joka kehittäjän on tarkistettava.

healthIndicatorColor = (terveys == “hyvä”)? “Vihreä”: (terveys == “reilu”)? ”Keltainen”: (terveys == “huono”)? “Punainen”: (terveys == “elämän_tuki”)? ”Oranssi”: “violetti”;

Mahdollinen ratkaisu: Ehdolliset operaattorit ovat hyödyllisiä, kun ne korvaavat korkean tiheyden arvoja, jotka on asetettu if-lauseilla toteutettujen ehtojen perusteella. Ehdolliset operaattorit ovat tuhoisia, kun ne korvaavat jopa pari toisiinsa upotettuja päätöksiä. Imperatiivit, jotka sopivat yhdellä rivillä, ovat päätavoite ehdollisille operaattoreille, kun taas olosuhteet, jotka vaativat useita rivejä, ovat if-lauseiden verkkotunnus. Jos if-lauseiden tai ehdollisten operaattorien törkeä käyttö on korjattava, jotta jommankumman näistä rakenteista voidaan käyttää asianmukaista käyttöä. (Huomaa: Muutokset saattavat edellyttää merkittävää uudelleenkehittämistä.)

if (terveys == “hyvä”) {
 healthIndicatorColor = ”vihreä”;
} muu jos (terveys == ”kohtuullinen”) {
 healthIndicatorColor = ”keltainen”;
} muu jos (terveys == ”huono”) {
 healthIndicatorColor = “punainen”;
} muu jos (terveys == “elämän_tuki”) {
 healthIndicatorColor = ”oranssi”;
} muuta {
 healthIndicatorColor = “violetti”;
}
label1.Color = (label1IsRequired)? "punamusta";
label2.Color = (label2IsRequired)? "punamusta";
label3.Color = (label3IsRequired)? "punamusta";

Useita paluulausekkeita vs. yksi paluulausunto

Kaksi erityistä tyyliä, jotka johtavat argumentteihin, ovat monta palautusta ja yksi palautus. Erimielisyyksiä syntyy siitä, pitäisikö menetelmillä olla yksi palautuslausunto vai voidaanko useita palautuslausuntoja hyväksyä. Jokaisella lähestymistavalla on positiivisia ja negatiivisia näkökohtia.

Useita palautuslausuntoja: Usean palautuksen lausekkeet voivat auttaa koodia, jota on vaikea ymmärtää, seurata ja testata. Menetelmät, joissa on useita palautuksia, voivat kuitenkin olla lyhyempiä kuin toiminnot, joissa on yksi palautus.

SomeDataType someMethod (param1, param2, param3) {
 SomeDataType retVal;
 if (param1 == nolla) {
 retVal = nolla
 }
 if (retVal == nolla) {
 paluu retVal;
 }
 
 if (param2! = nolla) {
 retVal = param2;
 }
 jos (retVal.Equals (param2)) {
 paluu retVal;
 }
 
 retVal = param3;
 paluu retVal;
}

Yksi paluulauseke: Yksi palautuslausunto voi johtaa pitkään menetelmään. Näillä menettelyillä on kuitenkin yhden pisteen poistuminen, mikä yksinkertaistaa testausta ja virheenkorjausta.

SomeDataType someMethod () {
 SomeDataType retVal;
 // satoja tai tuhansia rivikoodeja
 paluu retVal;
}

Mahdollinen ratkaisu: Useat palautukset vaikeuttavat koodin ymmärtämistä, seuraamista ja testaamista, kun niitä käytetään epäjohdonmukaisesti. Yksittäiset paluulausekkeet johtavat pitkiin menetelmiin, kun niitä etenevät pitkät koodirivit. Näitä vedettyjä etäisyyksiä voidaan lyhentää tai ainakin tehdä luettaviksi käyttämällä useita palautuslausuntoja yhden sijasta. Yksittäiset palautukset ovat täysin hyväksyttäviä, kun ne seuraavat lyhyitä koodinpätkiä. Yhden paluulausekkeen tai usean palautuksen räikeä väärinkäyttö tulisi korjata, jotta voidaan soveltaa yhden näistä tyyleistä hyväksyttyä käyttötapausta. (Huomaa: Korjaus saattaa vaatia merkittävää uudelleenkorjausta.)

SomeDataType someMethod (param1, param2, param3) {
 if (param1 == nolla || param3 == nolla) {
 palauta nolla;
 }
 
 SomeDataType retVal = nolla;
 if (param2! = nolla {
 retVal = param2;
 } else if (param1! = nolla) {
 retVal = param1;
 } ele if (param3! = nolla) {
 retVal = param3;
 }
 paluu retVal;
}
SomeDataType someMethod (param1, param2) {
 SomeDataType retVal = nolla;
 varten (int i = 0; i  jos (param1 [i] .equals (param2)) {
 retVal = param1 [i];
 tauko;
 }
 }
 paluu retVal;
} Katkaise ja jatka käyttöä silmukoissa

Tauko- ja jatkorakenteet ovat tiiviin keskustelun aiheita. Argumentin toisella puolella kehittäjät väittävät, että murtuminen ja jatkaminen voi yksinkertaistaa ohjauksen kulkua. Muut ohjelmoijat väittävät, että nämä ominaisuudet vaikeuttavat ohjelman logiikkaa. Taukoa ja jatkamista voidaan ehdottomasti käyttää koodin yksinkertaistamiseen tai vaikeuttamiseen. Nämä linjat voidaan havaita.

Katkaise ja jatka käyttöä: Elementit voivat yksinkertaistaa koodia, mutta ne voivat myös tarpeettomasti monimutkaista niitä.

SomeDataType someMethod (param1, param2) {
 SomeDataType retVal = nolla;
 varten (int i = 0; i  if (param1 [i] == nolla) {
 jatkaa;
 }
 jos (param1 [i] .equals (param2)) {
 retVal = param1 [i];
 tauko;
 }
 }
 paluu retVal;
}
SomeDataType someMethod (data, param1) {
 SomeDataType retVal = nolla;
 tee jotain:
 varten (int i = 0; i  if (i> = datanpituus) {
 tauko;
 }
 jos (data [i] .equals (param1)) {
 retVal = data [i];
 } muuta {
 jatkaa;
 }
 }
if (retVal == nolla) {
 data - refreshData ();
 siirry annosteluun;
 }
paluu retVal;
}

Mahdollinen ratkaisu: Useimmat kehittäjät väittävät, että koodin tulisi käyttää yksinkertaisia ​​mekanismeja ohjausvirtaan. Mitkä erityiset mekanismit ovat yksinkertaisia, on keskustelun lähde. Tämä väite vähenee paljon, kun kutakin instrumenttia käytetään laajalti hyväksyttyillä tavoilla. Hyväksytyt lähestymistavat ovat olemassa taukoja varten ja jatkuvat. Noudata näitä yleissopimuksia erimielisyyksien estämiseksi ja valvontavirtojen yksinkertaistamiseksi. Kaikki valvontavälineet, jotka rikkovat räikeästi näitä normeja, olisi korjattava ilman keskustelua.

SomeDataType someMethod (data, param1) {
 SomeDataType retVal = nolla;
 varten (int i = 0; i  if (data [i] == nolla) {
 jatkaa; // ohita loput silmukka
 }
 jos (data [i] .equals (param2)) {
 retVal = data [i];
 tauko; // älä silmukka enää b / c olen valmis
 }
 }
 paluu retVal;
}

Puolustavat poikkeukset

Poikkeukset ovat keino ilmaista ongelma tai torjua tuleva ongelma. Minkälainen päänsärky tulisi osoittaa tai miten se tulee lievittämään, mitkä koodin osat ovat kiihkeän keskustelun aiheita. Erimielisyyden toisessa päässä koodaajat väittävät, että tunkeutuvat puolustavat poikkeukset estävät virheet ja tekevät niistä helpon sijainnin. Tämä puolustusluettelo voi kuitenkin tehdä koodista paisuneen ja vaikea ymmärtää, kuten jotkut ohjelmoijat ovat väittäneet. Keskustelujen molemmin puolin toimivilla kehittäjillä on kohta. Puolustavilla poikkeuksilla on sekä etuja että haittoja.

Puolustavien poikkeusten edut ja haitat: Virheitä ja muita ongelmia vastaan ​​voidaan suojata suojaamalla poikkeuksilla pienin haitoin. Nämä puutteet suurenevat, kun tekniikka on erottelematon.

void someMethod (param1, param2) {
 if (param1 == nolla || param2 == nolla) {
 heitä uusi ArgumentNullException (“Yksi tai useampi parametri puuttuu”);
 }
 // tee menetelmätavaroita
}
void someMethod (param1, param2) {
 // kymmeniä linjoja puolustavia tarkastuksia ...
 // tee muu menetelmä
}

Mahdollinen ratkaisu: Puolustuksellisten poikkeusten puutteet ovat pienimmät, kun niitä käytetään hyväksytyissä käyttötavoissa. Kaikki näistä yleissopimuksista poikkeavan tekniikan käyttöönotto olisi korjattava, jollei pakottavasta syystä ole ilmoitettu.

public void someMethod (param1, param2) {
 // tarkista jokainen parametri julkisella menetelmällä
 if (param1 == nolla || param2 == nolla) {
 heitä uusi ArgumentNullException (“Yksi tai useampi parametri puuttuu”);
 }
 
 // torju ongelmat virheellisten tietojen perusteella
 if (! isValid (param1) ||! isValid (param2)) {
 heitä uusi InvalidParameterException (“Yksi tai useampi parametri on virheellinen”);
 }
 
 // tee jotain parametreilla
}

Paketoida

Näitä koodirakenteita ja tekniikoita käyttävät sekä hyvät että huonot kehittäjät. Ohjelmoijat ovat ihmisiä. Ihmisillä on taipumuksia. Nämä taipumukset ilmenevät koodina. Toisinaan kehittäjän impulssit saavat hänet kirjoittamaan koodia, jota muut koodaajat perustellusti arvostelevat. Pilloriedossa oleva kehittäjä ei välttämättä ole huono ohjelmoija. Häntä kritisoiva koodaaja ei välttämättä ole hyvä kehittäjä. Molemmat ihmiset ovat todennäköisesti joutuneet harhaan yhdessä vaiheessa heidän mieltymyksensä. Nämä toiveet eivät saisi johtaa kehityksen rappeutumiseen loputtomiin loukkausten virtaihin, jotka heitettiin toisiinsa. Ohjelmoijien tulisi pikemminkin tarkistaa toistensa koodi, rajoittaa taistelunsa pahimpiin osiin ja sopia ratkaisevansa tietyt argumentit edellä esitettyjen sääntöjen avulla.