Keskeistä havaintoa
1. Kirjoita puhdasta koodia, joka on luettavaa ja ylläpidettävää
Ainoa pätevä mittari koodin laadulle: WTFs/minuutti
Luettavuus on ensisijainen. Puhdas koodi tulisi olla helposti ymmärrettävää muille kehittäjille. Sen tulisi olla yksinkertaista, eleganttia ja vailla turhaa hälinää. Pyri kirjoittamaan koodia, joka selkeästi ilmaisee tarkoituksensa ilman laajoja kommentteja. Käytä merkityksellisiä muuttujien ja funktioiden nimiä, pidä funktiot pieniä ja keskittyneitä, ja järjestä koodi loogisesti.
Ylläpidettävyys mahdollistaa kehityksen. Koodi, jota on vaikea muuttaa, muuttuu vastuuksi. Suunnittele koodisi joustavaksi ja modulaariseksi, jotta se voi sopeutua muuttuviin vaatimuksiin. Noudata periaatteita kuten DRY (Älä toista itseäsi) ja SOLID luodaksesi löyhästi kytkettyjä, erittäin koherentteja järjestelmiä. Refaktoroi armotta parantaaksesi koodin rakennetta ilman käyttäytymisen muuttamista.
Puhdas koodi kannattaa. Vaikka puhtaan koodin kirjoittaminen vaatii enemmän alkuperäistä vaivannäköä, se säästää merkittävästi aikaa ja vaivannäköä pitkällä aikavälillä. Puhdas koodi on helpompi virheenkorjata, laajentaa ja ylläpitää. Se mahdollistaa kehittäjien työskentelevän tehokkaammin ja vähentää virheiden syntymisen riskiä muutosten aikana. Tee puhtaasta koodista keskeinen osa kehityskäytäntöäsi.
2. Noudata merkityksellisiä nimeämiskäytäntöjä
Muuttujan, funktion tai luokan nimi tulisi vastata kaikkiin suuriin kysymyksiin. Sen tulisi kertoa, miksi se on olemassa, mitä se tekee ja miten sitä käytetään.
Käytä tarkoitusta paljastavia nimiä. Valitse nimiä, jotka selkeästi välittävät muuttujien, funktioiden ja luokkien tarkoituksen ja käyttäytymisen. Vältä yksittäisten kirjainten nimiä tai kryptisiä lyhenteitä. Käytä ääntämiskelpoisia nimiä, joita on helppo etsiä. Esimerkiksi:
- Huono: d (kulunut aika päivinä)
- Hyvä: kulunutAikaPäivinä
Ole johdonmukainen ja tarkka. Käytä johdonmukaisia nimeämiskäytäntöjä koko koodipohjassasi. Ole tarkka välttääksesi epäselvyyksiä - esimerkiksi käytä merkityksellisiä erotteluja kuten getActiveAccounts() ja getActiveAccountInfo(). Vältä koodauksia tai etuliitteitä, jotka lisäävät hälinää ilman arvoa. Luokkien nimet tulisi olla substantiiveja, metodien nimet verbejä.
Nimen pituuden tulisi vastata laajuutta. Käytä pidempiä, kuvaavampia nimiä muuttujille ja funktioille, joilla on suurempi laajuus. Lyhyet nimet ovat hyväksyttäviä pienissä, paikallisissa laajuuksissa. Nimen pituuden tulisi olla suhteessa sen käyttölaajuuteen. Optimoi luettavuus ja ymmärrettävyys kontekstissa, jossa nimeä käytetään.
3. Pidä funktiot pieninä ja keskittyneinä
Funktioiden tulisi tehdä yksi asia. Niiden tulisi tehdä se hyvin. Niiden tulisi tehdä se vain.
Pieni on kaunista. Funktioiden tulisi olla pieniä - tyypillisesti 5-10 riviä pitkiä. Niiden tulisi mahtua yhdelle näytölle ja olla heti ymmärrettäviä. Erottele koodi hyvin nimettyihin apufunktioihin sen sijaan, että kirjoittaisit pitkiä, monimutkaisia funktioita. Pienet funktiot ovat helpompia ymmärtää, testata ja ylläpitää.
Tee yksi asia hyvin. Jokaisella funktiolla tulisi olla yksi, selkeä tarkoitus. Jos funktio tekee useita asioita, erottele ne erillisiin funktioihin. Merkkejä siitä, että funktio tekee liikaa, ovat:
- Useita abstraktiotasoja
- Useita osioita tai koodilohkoja
- Lukuisia parametreja
Ylläpidä yhtä abstraktiotasoa. Funktiossa olevat lauseet tulisi olla kaikki samalla abstraktiotasolla. Älä sekoita korkean tason logiikkaa matalan tason yksityiskohtiin. Erottele matalan tason toiminnot erillisiin funktioihin. Tämä parantaa luettavuutta pitämällä funktiot keskittyneinä ja käsitteellisesti yksinkertaisina.
4. Harjoittele oikeaa muotoilua ja järjestelyä
Koodin muotoilu on viestintää, ja viestintä on ammattikehittäjän ensimmäinen tehtävä.
Johdonmukainen muotoilu on tärkeää. Käytä johdonmukaisia sisennystä, rivinvaihtoja ja välejä koko koodissasi. Tämä parantaa luettavuutta ja vähentää kognitiivista kuormitusta. Sopikaa tiimisi kanssa muotoilustandardeista ja käyttäkää automatisoituja työkaluja niiden noudattamiseksi. Tärkeitä muotoiluperiaatteita ovat:
- Oikea sisennys
- Johdonmukainen aaltosulkujen sijoittelu
- Loogiset rivinvaihdot
- Sopiva tyhjävälit
Järjestä koodi loogisesti. Ryhmittele liittyvä koodi yhteen ja erota epäolennaiset osat. Käytä tyhjää riviä luodaksesi "kappale" taukoja loogisten osioiden välille. Aseta liittyvät funktiot lähelle toisiaan. Pidä tiedostot keskittyneinä yhteen käsitteeseen tai komponenttiin. Pilko suuret tiedostot pienemmiksi, keskittyneemmiksi, kun se on tarpeen.
Noudata standardikäytäntöjä. Noudata standardikäytäntöjä kielesi ja yhteisösi osalta. Tämä tekee koodistasi tutumpaa ja helpommin saavutettavaa muille kehittäjille. Esimerkiksi Javassa:
- Luokkien nimet käyttävät PascalCasea
- Metodien nimet käyttävät camelCasea
- Vakioita käytetään ALL_CAPS-muodossa
5. Hallitse riippuvuuksia ja vältä päällekkäisyyksiä
Päällekkäisyys voi olla kaiken pahan alku ohjelmistossa.
Poista päällekkäisyydet. Toistuva koodi on hukattu mahdollisuus abstraktioon. Kun näet päällekkäisyyksiä, erottele yhteinen koodi uudelleenkäytettäväksi funktioksi tai luokaksi. Tämä parantaa ylläpidettävyyttä keskittämällä logiikan ja vähentämällä epäjohdonmukaisista muutoksista johtuvia riskejä. Huomioitavia päällekkäisyyksien tyyppejä ovat:
- Identtiset koodilohkot
- Samankaltaiset algoritmit pienillä eroilla
- Toistuvat switch/case- tai if/else-ketjut
Hallitse riippuvuuksia huolellisesti. Minimoi riippuvuudet moduulien välillä vähentääksesi kytkentää. Käytä riippuvuuden injektiota ja ohjaus-inversiota tehdäksesi koodista modulaarisempaa ja testattavampaa. Noudata Riippuvuuden Inversio -periaatetta - tukeudu abstraktioihin, ei konkreettisiin asioihin. Tämä tekee koodistasi joustavampaa ja helpompaa muuttaa.
Käytä vähäisen tiedon periaatetta. Moduulin ei tulisi tietää manipuloimiensa objektien sisällöstä. Tämä vähentää moduulien välistä kytkentää. Esimerkiksi, käytä Demeterin lakia - metodin tulisi kutsua metodeja vain:
- Oman objektinsa
- Parametreina annettujen objektien
- Luomiensa objektien
- Suorien komponenttiobjektiensa
6. Käsittele virheitä sujuvasti
Virheiden käsittely on tärkeää, mutta jos se hämärtää logiikkaa, se on väärin.
Käytä poikkeuksia virhekoodien sijaan. Poikkeukset ovat siistimpiä eivätkä sotke koodisi päälogiikkaa. Ne mahdollistavat virheiden käsittelyn erottamisen onnellisesta polusta. Käyttäessäsi poikkeuksia:
- Luo informatiivisia virheilmoituksia
- Anna konteksti poikkeuksille
- Määritä poikkeusluokkia kutsujan tarpeiden mukaan
Älä palauta null-arvoa. Null-arvon palauttaminen johtaa null-osoitinpoikkeuksiin ja sotkee koodia null-tarkistuksilla. Sen sijaan:
- Palauta tyhjät kokoelmat nullin sijaan listoille
- Käytä Null Object -mallia
- Käytä Optionalia Javassa tai Maybea funktionaalisissa kielissä
Kirjoita try-catch-finally -lausumat ensin. Aloita try-catch-finally -rakenteella, kun kirjoitat koodia, joka voi heittää poikkeuksia. Tämä auttaa määrittämään laajuuden ja odotukset kutsuvalle koodille. Se varmistaa, että resurssit hallitaan ja vapautetaan oikein, jopa virhetilanteissa.
7. Kirjoita perusteellisia yksikkötestejä
Testikoodi on yhtä tärkeää kuin tuotantokoodi.
Noudata TDD:n kolmea lakia. Testivetoisen kehityksen (TDD) avulla parannat koodin laatua ja rakennetta:
- Kirjoita epäonnistuva testi ennen kuin kirjoitat mitään tuotantokoodia
- Kirjoita vain tarpeeksi testiä osoittamaan epäonnistuminen
- Kirjoita vain tarpeeksi tuotantokoodia testin läpäisemiseksi
Pidä testit puhtaina ja ylläpidettävinä. Sovella samoja koodin laatustandardeja testiesi osalta kuin tuotantokoodillesi. Refaktoroi ja paranna testikoodia säännöllisesti. Hyvin rakennetut testit toimivat dokumentaatioina ja mahdollistavat pelottoman refaktoroinnin tuotantokoodissa.
Tavoittele kattavaa testikattavuutta. Kirjoita testejä, jotka kattavat äärimmäiset tapaukset, rajat ja virhetilanteet - eivät vain onnellista polkua. Käytä koodikattavuustyökaluja tunnistaaksesi testikattavuuden aukot. Muista, että 100 % kattavuus ei takaa virheettömyyttä, mutta se antaa luottamusta refaktorointiin ja muutoksiin.
8. Refaktoroi koodia jatkuvasti
Jätä leirintäalue puhtaammaksi kuin löysit sen.
Refaktoroi tilaisuuden mukaan. Paranna koodin rakennetta aina, kun työskentelet koodin parissa. Noudata Poikakoulusääntöä: jätä koodi paremmaksi kuin löysit sen. Pienet, asteittaiset parannukset kerryttävät ajan myötä ja estävät koodin rapistumista. Yleisiä refaktorointitekniikoita ovat:
- Metodien tai luokkien erottaminen
- Nimeäminen selkeyden vuoksi
- Monimutkaisten ehtojen yksinkertaistaminen
- Päällekkäisyyksien poistaminen
Refaktoroi turvallisesti testien avulla. Varmista, että sinulla on vahva testisarja ennen refaktorointia. Tee pieniä, asteittaisia muutoksia ja suorita testit usein. Tämä antaa sinulle luottamusta siihen, että muutoksesi eivät riko olemassa olevaa toiminnallisuutta. Käytä automatisoituja refaktorointityökaluja, kun niitä on saatavilla, virheiden syntymisen riskin vähentämiseksi.
Tasapainota refaktorointi ja arvon tuottaminen. Vaikka jatkuva refaktorointi on tärkeää, älä anna sen halvaannuttaa edistystä. Tavoittele "riittävän hyvää" sen sijaan, että pyrit täydellisyyteen. Suuntaa refaktorointiponnistuksesi koodin ongelmallisimpiin tai useimmin muutettuihin alueisiin. Viesti refaktoroinnin arvo sidosryhmille varmistaaksesi tuen jatkuvalle koodin parantamiselle.
9. Sovella olio- ja funktionaalisen ohjelmoinnin periaatteita
Objektit piilottavat tietonsa abstraktioiden taakse ja paljastavat funktioita, jotka toimivat kyseisten tietojen päällä. Tietorakenteet paljastavat tietonsa ja niillä ei ole merkityksellisiä funktioita.
Käytä olio-ohjelmoinnin periaatteita viisaasti. Sovella periaatteita kuten kapselointi, perintö ja polymorfismi luodaksesi joustavia, modulaarisia rakenteita. Noudata SOLID-periaatteita:
- Yhden vastuun periaate
- Avoin-suljettu periaate
- Liskovin korvausperiaate
- Rajapintojen erotteluperiaate
- Riippuvuuden inversioperiaate
Hyödynnä funktionaalisen ohjelmoinnin käsitteitä. Jopa olio-ohjelmointikielissä funktionaaliset ohjelmointitekniikat voivat johtaa puhtaampaan koodiin:
- Puhtaat funktiot ilman sivuvaikutuksia
- Muuttumattomat tiedot
- Korkeamman tason funktiot
- Funktion koostaminen
Valitse oikea lähestymistapa ongelmaan. Olio- ja funktionaalisilla paradigmoilla on kummallakin vahvuutensa ja heikkoutensa. Käytä olio-ohjelmointia, kun sinun on mallinnettava monimutkaisia alueita käyttäytymisellä. Käytä funktionaalisia lähestymistapoja tietojen muuntamiseen ja prosessointiputkiin. Monet modernit kielet tukevat hybridilähestymistapaa, jolloin voit käyttää parasta työkalua jokaisessa järjestelmäsi osassa.
10. Huomioi rinnakkaisuus huolellisesti
Rinnakkaisuus on irrottautumisstrategia. Se auttaa meitä irrottamaan sen, mitä tehdään, siitä, milloin se tehdään.
Ymmärrä rinnakkaisuuden haasteet. Rinnakkaisohjelmointi tuo mukanaan monimutkaisuutta ja mahdollisia hienovaraisia virheitä. Yleisiä ongelmia ovat:
- Kilpailuolosuhteet
- Kuolemat
- Ohitetut signaalit
- Muistin näkyvyysongelmat
Erota rinnakkaisuuteen liittyvät huolenaiheet. Pidä rinnakkaisuuteen liittyvä koodi erillään muusta koodista. Tämä helpottaa sen ymmärtämistä ja testaamista. Käytä abstraktioita kuten Executors, Futures ja Actors hallitaksesi rinnakkaisuutta sen sijaan, että työskentelisit raakojen säikeiden kanssa.
Suosi muuttumattomuutta ja puhtaita funktioita. Muuttumattomat objektit ja puhtaat funktiot ovat luontaisesti säieturvallisia. Ne poistavat monia rinnakkaisuusongelmia välttämällä jaettua muuttuvaa tilaa. Kun muuttuva tila on tarpeen, käytä asianmukaisia synkronointitekniikoita ja harkitse atomisten muuttujien tai rinnakkaisten kokoelmien käyttöä.
Viimeksi päivitetty:
FAQ
What's "Clean Code: A Handbook of Agile Software Craftsmanship" about?
- Focus on Clean Code: "Clean Code" by Robert C. Martin emphasizes writing code that is easy to read, understand, and maintain.
- Professionalism in Coding: It argues that clean code is a hallmark of professionalism in software development.
- Practical Advice: The book provides guidelines, examples, and case studies to help developers write clean and efficient code.
Why should I read "Clean Code: A Handbook of Agile Software Craftsmanship"?
- Improve Coding Skills: It teaches how to write code that is clean, efficient, and maintainable.
- Learn from Experts: Part of the Robert C. Martin series, known for its technical and pragmatic approach.
- Long-term Benefits: Writing clean code reduces maintenance costs and makes you a more valuable developer.
What are the key takeaways of "Clean Code: A Handbook of Agile Software Craftsmanship"?
- Code Readability: Emphasizes that code should be easy to read and understand.
- Single Responsibility Principle: Advocates for each class or function to have one reason to change.
- Continuous Improvement: Encourages developers to continuously improve their code, following the Boy Scout Rule.
How does "Clean Code: A Handbook of Agile Software Craftsmanship" define clean code?
- Elegance and Efficiency: Clean code is described as elegant and efficient, with minimal dependencies.
- Readable and Maintainable: It should read like well-written prose, making the designer's intent clear.
- Focused and Single-minded: Each function, class, and module should have a single, clear purpose.
What is the Single Responsibility Principle in "Clean Code: A Handbook of Agile Software Craftsmanship"?
- One Reason to Change: A class or module should have one, and only one, reason to change.
- Improves Cohesion: Ensures that classes are cohesive, with closely related methods and variables.
- Facilitates Maintenance: Makes the code easier to maintain and extend, reducing the impact of changes.
What is the "Boy Scout Rule" mentioned in "Clean Code: A Handbook of Agile Software Craftsmanship"?
- Continuous Improvement: Suggests leaving the codebase cleaner than you found it.
- Small, Incremental Changes: Encourages making small improvements, like renaming variables or breaking up functions.
- Professional Responsibility: Presented as a professional responsibility to ensure maintainability.
How does "Clean Code: A Handbook of Agile Software Craftsmanship" approach Test-Driven Development (TDD)?
- Fundamental Discipline: TDD is crucial for writing clean, reliable code.
- Three Laws of TDD: Write a failing test first, write code to pass the test, then refactor.
- Benefits: Helps catch bugs early and improves code design.
What are "code smells" according to "Clean Code: A Handbook of Agile Software Craftsmanship"?
- Definition: Indicators of potential problems that hinder readability or maintainability.
- Examples: Long methods, large classes, and duplicated code.
- Addressing Smells: Provides heuristics and refactoring techniques to improve code quality.
How does "Clean Code: A Handbook of Agile Software Craftsmanship" suggest handling exceptions?
- Prefer Exceptions: Use exceptions instead of error codes for better context and management.
- Provide Context: Include meaningful messages and context when throwing exceptions.
- Avoid Checked Exceptions: Suggests using unchecked exceptions for cleaner code.
What role do unit tests play in "Clean Code: A Handbook of Agile Software Craftsmanship"?
- Ensure Code Quality: Unit tests ensure code works as intended and remains maintainable.
- Test-Driven Development: Advocates writing tests before production code.
- Clean and Readable Tests: Tests should be as clean and readable as production code.
What is the role of refactoring in "Clean Code: A Handbook of Agile Software Craftsmanship"?
- Continuous Improvement: Refactoring improves code structure and readability without changing functionality.
- Techniques: Provides techniques like Extract Method and Rename Variable to enhance code quality.
- Fearless Refactoring: With comprehensive tests, developers can refactor confidently.
What are the best quotes from "Clean Code: A Handbook of Agile Software Craftsmanship" and what do they mean?
- "Clean code does one thing well." Emphasizes focus and clarity in code.
- "Leave the campground cleaner than you found it." Encourages continuous improvement of the codebase.
- "You know you are working on clean code when each routine you read turns out to be pretty much what you expected." Highlights the importance of readability and predictability.
Arvostelut
Clean Code saa pääasiassa myönteisiä arvioita periaatteistaan, jotka koskevat luettavan ja ylläpidettävän koodin kirjoittamista. Lukijat arvostavat käytännön neuvoja nimien, funktioiden ja testauksen suhteen. Kirjan Java-keskeisyys ja jotkin liian tiukat ohjeet ovat yleisiä kritiikin kohteita. Monet pitävät sitä välttämättömänä lukemisena kehittäjille, vaikka jotkut kokevat sen vähemmän hyödylliseksi kokeneille ohjelmoijille. Tapaustutkimuksia ja refaktorointiesimerkkejä kiitellään joiltakin, mutta toiset kritisoivat niitä liioitelluiksi. Yhteenvetona arvioijat ovat yhtä mieltä siitä, että kirja tarjoaa arvokkaita näkemyksiä koodin laadusta, vaikka kaikki ehdotukset eivät olekaan yleisesti sovellettavissa.
Similar Books
