I came across my share of beautifully written, over-engineered code... isang moment ako ay nag-iisip “That’s an interesting way to do that” at ang susunod na minuto ikaw ay nag-iisip “no hell’s going on here!” I’ve also suffered from writing over-engineered code, kung saan ikaw ay nag-iisip kaya malapit sa future na ikaw kompromiso. ang mga (You Aren't Gonna Need It) prinsipyo ay isang mahusay na paraan upang ipatupad ang over-engineering: functionalities ay dapat na i-implementate lamang kapag kailangan mo sila, hindi sa posibilidad na kailangan mo sila. Ngayon YAGNI Ngayon Sa mga simpleng salita, ang over-engineering ay gumagawa ng software / sistema na disenyo ng mas kompleksong kaysa sa kinakailangan; ito ay karaniwang ginawa dahil gusto mong magdagdag ng karagdagang functionality sa iyong mga bahagi upang i-simplify ang pag-implementasyon ng A, lamang upang magdagdag ng functionality para sa B pagkatapos. Mayroon kaming code base para sa pag-managing invitations; ito ay isang inherited, legacy code base na may teknolohiya na utang na gumagawa ng interest. Ang karamihan na maaari mong magtrabaho sa legacy code, ang higit pa ang isang bagay sa ibang lugar ay bumaba. Kailangan mo upang i-revert sa karamihan ng mga kaso at magsimula sa buong lugar. Pagtatrabaho sa paligid ng legacy code ay nagsisimula upang makakuha ng interes sa teknolohiya na utang; ito ay isang stand-off sa pagitan ng pag-aralan ng mga tampok sa buong app o magdagdag ng higit pa ng teknolohiya na utang sa code base. Ang ikalawang solusyon na natagpuan namin ay abstraction. Kailangan namin upang makikita ang mga paraan upang modularize ang mga bagong mga tampok o Kapag nag-kolaborate sa maraming mga tao sa isang codebase (na kung saan ay halos lahat ng pagkakataon), at para sa mga kumpanya na mas interesado sa paghahatid ng mga tampok kaysa sa kalidad ng code, ang mga review ng code ay karaniwang nakakaalam. Para sa mga problema tulad ng over-engineering at overabstraction, Traditional line-by-line code review ay karaniwang nangangailangan ng mga sistematikong mga problema na ito. I-check ang isang component na itinatag ng ilang linggo na ang nakaraan upang suportahan ang integration ng isang feature, sumusuporta sa prinsipyo ng DRY, at makikita na ngayon ay may 10 interconnected/similar features na depende sa component. Spaghetti ng dry code Kami ay gumagamit ng DRY (Don't Repeat Yourself) gospel dahil ito ay lumikha ng trabaho, at ang mga developer ay inherently lazy (sa isang mahusay na paraan). Ang prinsipyo ng DRY ay gumagana din sa orthogonal na mga sistema: maliit na, self-contained mga bahagi na kombinasyon upang lumikha ng isang sistema. . Ang mga sistema ay dapat na binubuo ng isang set ng kooperatibo na mga module, ang bawat isa ay nagtatrabaho ng functionality independiyenteng sa iba't ibang mga Alıntılar - Ang Pragmatic Programmer: mula sa Journeyman sa Master. Kailangan na magkaroon ng mas mataas na pag-eye sa ortogonal na mga sistema at sa DRY code; ito ay mas madali upang mag-kombinasyon ang mga reusable function na iyong lumikha sa isa sa isa at i-scale ang mga ito habang ang repository ay lumabas kapag hindi sila ay nabuksan at abstrak, sa kung saan ang punto na ikaw ay humihingi ng isang rigid na sistema na naka-interwoven kaya ito ay magkakaroon ng komplikadong upang mag-connect kung ano ang mga aspeto ng code na hindi sumusuporta sa isang eksaktong halimbawa, makikita mo ang iyong pag-duplicate ng code dahil paggawa nito ay gumagana para sa isang bagong koneksyon. Congratulations, you've achieved Spaghetti code that can't bend. upang gamitin ang isang tunay na Mga Component Ang iyong mga bahagi ay hindi kailangang mag-focus lamang sa pag-evite repetition, ngunit din sa maging maliit na abstractions ng buong sistema; sa halip, ikaw ay nagsimula na may mga bahagi na napaka-complex na sila ay maaaring madaling i-break sa isang single pagbabago sa isang konektado na bahagi. Sa paggawa ng reusable code, ang paraan ay upang i-writing code na hindi depende sa anumang iba pang block ng code upang gumagana sa anumang paraan. Reusability ay dapat gamitin bilang isang tool at hindi ang target; kapag ikaw ay may reusable UI mga bahagi na may mga negosyo o API logic sa parehong bahagi, ikaw ay sa isang highway sa over-abstraction. Ito ay nagsisimula na maliit, at bago ka malaman kung ano ang nangyayari, ang sakit ay pinagsasama Patterns upang makuha ang over-abstraction at over-engineering Modularidad Modularidad Modularidad Ang modularity ay nangangahulugan sa pag-unlad ng iyong sistema sa mas maliit na, independent codes/components na tinatawag na modules. Mangyaring mag-attention sa salita 'smaller'; ito ay posible na magkaroon ng isang bumaba module na may higit pa ng code kaysa sa kinakailangang, na nagpapakita ng over-abstraction at dapat ay inihayag. Ang over-abstraction ay talagang lamang isang nangangahulugang pagsisiyahan sa modularity. Ang iyong modules ay dapat na mag-function independently mula sa iba pang mga modules, lamang na-exposing ang mga kinakailangang data. Ang mga pagbabago sa mababang, modular, structured code ay dapat na tumutulong lamang sa mga modules, walang anumang mga kaskading mga epekto. Functional ang unang Ang isang mahusay na paraan upang bumuo ng ortogonal na mga sistema at madaling pag-iwan ang over-abstraction ay upang bumuo ng functionality na unang, pagkatapos ay mga tampok; ito ay matatagpuan na may Component-Based architecture (paliwanag ang mga bahagi ng UI mula sa mga bahagi ng stateful). Ang layunin ng functionality ay mag-focus sa pinakamalaking reusable unit ng code na inilagay upang i-implementate ang feature. A Login feature ay binubuo ng mga sumusunod na mga functionality: makuha ang username at password (UI), validate user data, redirect sa user profile / reject collected user data. Walang mga medalya para sa over-sophisticated code Pagkatapos ng pag-script ng bawat pag-implementasyon ng code, panoorin ang iyong sarili kung mayroon ka ng mas madaling o mas simpleng paraan upang makakuha ng parehong resulta. Karamihan sa amin ay narinig ng mga kasaysayan tungkol sa code na maaaring i-edit o magtrabaho sa pamamagitan lamang ng isang tao sa kumpanya, na kung saan ay hindi isang gawain upang maging proud ng. Ang pag-script ng code na maaari lamang na magtataguyod sa pamamagitan ng iyo ay karaniwang ay nangangahulugan na ito ay over-sophisticated o gumagamit ng hindi-orthodox procedures. Isang mahusay na halimbawa ng coding gamit ang hindi-orthodox procedures ay ang Gilfoyle's Hard Drives mula sa artikulong: Ang isang former employee ng isang kumpanya ay kilala para sa hindi checking sa code at para sa may mga programa at mga bahagi ng code base sa kanyang hard drive (imagine ang overhead para sa pag-usapan ng produktong ito!). "We ran out of columns" - Ang pinakamahusay na, worst codebase ni Jimmy Miller I've found myself writing excessively sophisticated code because I want to use a new technology/package/library I just learned about, without considering whether it's the simplest tool for the job. Ang pag-uugali para sa pag-uugali ng isang bagay na bagong ay mahusay, ngunit ang pag-atake sa kapag at kung saan ito ay dapat i-apply ay mas mahalaga. ang final Sa paghahanap para sa pag-script ng katunayan na mga code na sumusunod sa lahat ng posible na future at time-traveling kaso, ikaw ay nagsimula sa isang over-engineered codebase. Kailangan mong i-drop ito dahil ito ay hindi maaaring mag-script ng katunayan na code, sasabihin para sa sapat na mabuti na matugunan ang lahat ng iyong mga pangunahing mga kinakailangan. Ang prinsipyo ng DRY ay pangunahing; repetition ay pa rin isang kasalanan sa pag-unlad ng software. Ang prinsipyo ng DRY ay dapat i-apply sa isang orthogonal na sistema upang lumikha ng isang codebase na i-disconnect, na may bawat module independiyenteng at i-share data sa isang partikular na punto (feature module). Ang mga ito ay makakatulong
