𝗖𝗼𝗱𝗲 𝗗𝘂𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻 𝘃𝘀. 𝗪𝗿𝗼𝗻𝗴 𝗔𝗯𝘀𝘁𝗿𝗮𝗰𝘁𝗶𝗼𝗻𝘀
ડેવલપર્સ ઘણીવાર એક પસંદગી સામે સંઘર્ષ કરતા હોય છે.
તમારે 'Don't Repeat Yourself' સિદ્ધાંત અથવા થોડા કોડ ડુપ્લીકેશનને મંજૂરી આપવા વચ્ચે પસંદગી કરવી પડે છે.
DRY એ સોફ્ટવેર ડિઝાઇનમાં એક મુખ્ય નિયમ છે. પરંતુ તેનો અતિશય પીછો કરવાથી એક નવી સમસ્યા ઊભી થાય છે. તમે ખોટું એબ્સ્ટ્રેક્શન (wrong abstraction) બનાવી દો છો.
ખોટું એબ્સ્ટ્રેક્શન ડુપ્લીકેટ કોડ કરતા વધુ મોંઘું પડે છે.
આપણે એલિગન્ટ (elegant) કોડ લખવા માંગીએ છીએ. આપણે રીયુઝેબલ (reusable) લોજિક બનાવવા માંગીએ છીએ. આપણે એક જગ્યાએ બગ (bug) સુધારીએ અને તે બધે જ સુધરાઈ જાય તેવું ઈચ્છીએ છીએ. આ લક્ષ્ય યોગ્ય લાગે છે.
પરંતુ અકાળ એબ્સ્ટ્રેક્શન (premature abstraction) પ્રોજેક્ટની ઝડપ ઘટાડી દે છે. તે તમારા કોડને મેન્ટેન (maintain) કરવાની સરળતાને બગાડે છે.
જ્યારે તમે ખૂબ વહેલા એબ્સ્ટ્રેક્શન કરો છો, ત્યારે તમારે આ સમસ્યાઓનો સામનો કરવો પડે છે:
- વધેલી જટિલતા (complexity). ખરાબ એબ્સ્ટ્રેક્શન મૂંઝવણના સ્તરો ઉમેરે છે.
- જડ કોડ (rigid code). અન્ય ભાગોને તોડ્યા વિના એક ભાગ બદલવો મુશ્કેલ બની જાય છે.
- છુપાયેલું લોજિક. તમે કોડ લખવા કરતાં તેને ટ્રેસ (trace) કરવામાં વધુ સમય વિતાવો છો.
ક્યારેક, ડુપ્લીકેશન એ વ્યવહારુ (pragmatic) પસંદગી હોય છે. તે તમારા કોડને સરળ અને સ્પષ્ટ રાખે છે. તે તમને તમારા સિસ્ટમના ભાગોને સ્વતંત્ર રીતે બદલવાની મંજૂરી આપે છે.
જે સમસ્યા તમે હજુ સંપૂર્ણ રીતે સમજી નથી રહ્યા, તેના માટે જનરિક (generic) ઉકેલ ન બનાવો. જ્યાં સુધી પેટર્ન સ્પષ્ટ ન થાય ત્યાં સુધી રાહ જુઓ.