આવશ્યક વિકાસકર્તા કૌશલ્ય જે તમારા કોડને બહેતર બનાવશે

અનુવાદકની પ્રસ્તાવના: આ લેખ વાંચ્યા પછી, તમને આશ્ચર્ય થશે અથવા ગુસ્સો પણ થશે. હા, અમને પણ આશ્ચર્ય થયું: લેખકે ટીમમાં વંશવેલો વિશે, "તે ઝડપથી અને તર્ક વિના કરો" સ્થિતિ સાથે કાર્યોને સેટ કરવા વિશે ક્યારેય સાંભળ્યું ન હતું. હા, તે સાચું છે, આ થોડું વિચિત્ર લખાણ છે. ખરેખર, લેખક સૂચવે છે કે પ્રોગ્રામર સિસ્ટમ આર્કિટેક્ટની ભૂમિકા નિભાવે છે - તો પછી તમારે આર્કિટેક્ટની શા માટે જરૂર છે? પરંતુ આ બધા વાંધાઓ તમને મુખ્ય વસ્તુથી આંધળા ન કરવા જોઈએ - તેમ છતાં અમે આ ટેક્સ્ટ કેમ લીધો અને અનુવાદિત કર્યો. તે ભૂમિકાઓ વિશે વાત કરી રહ્યો નથી. આ લખાણ વ્યાવસાયિક અભિગમ અને જાગૃતિ વિશે છે. સત્ય એ છે કે જ્યાં સુધી તમે તમારી ક્રિયાઓના અર્થ વિશે વિચાર્યા વિના ફક્ત "તમને જે કહેવામાં આવે છે તે કરો" ત્યાં સુધી તમે ક્યારેય મહાન પ્રોગ્રામર બનશો નહીં.

બિનજરૂરી કોડને ના કહો. તમારે ફક્ત ત્રણ અક્ષરો એકસાથે મૂકીને શબ્દ બોલવાનો છે. ચાલો આ સાથે મળીને કરવાનો પ્રયાસ કરીએ: "Noooo!"

પરંતુ રાહ જુઓ. આપણે આ કેમ કરી રહ્યા છીએ? છેવટે, પ્રોગ્રામરનું મુખ્ય કાર્ય કોડ લખવાનું છે. પરંતુ શું તમારે કોઈ કોડ લખવાની જરૂર છે જે તમને પૂછવામાં આવે છે? ના! "કોડ ક્યારે ન લખવો તે સમજવું એ કદાચ પ્રોગ્રામર માટે સૌથી મહત્વપૂર્ણ કૌશલ્ય છે." વાંચી શકાય તેવા કોડની કલા.

અમે યાદ કરાવીએ છીએ: Habrના તમામ વાચકો માટે - Habr પ્રોમો કોડનો ઉપયોગ કરીને કોઈપણ સ્કિલબોક્સ કોર્સમાં નોંધણી કરતી વખતે 10 રૂબલ ડિસ્કાઉન્ટ.

સ્કિલબોક્સ ભલામણ કરે છે: પ્રેક્ટિકલ કોર્સ "મોબાઇલ ડેવલપર પ્રો".

પ્રોગ્રામિંગ એ સમસ્યા હલ કરવાની કળા છે. અને તમે આ કળાના માસ્ટર છો.
કેટલીકવાર, શક્ય તેટલી ઝડપથી કામ શરૂ કરવાના પ્રયાસમાં, આપણે હાથમાં રહેલું કાર્ય પૂર્ણ કરવા સિવાય બીજું કંઈ જ વિચારતા નથી. અને આ વધુ ગંભીર સમસ્યાઓનું કારણ બની શકે છે.

પ્રોગ્રામરો શેની તરફ આંખ આડા કાન કરે છે?

તમે લખો છો તે તમામ કોડ અન્ય વિકાસકર્તાઓ માટે સમજી શકાય તેવા હોવા જોઈએ, અને પરીક્ષણ અને ડીબગ થયેલ હોવા જોઈએ.

પરંતુ એક સમસ્યા છે: તમે જે પણ લખો છો, તે તમારા સૉફ્ટવેરને જટિલ બનાવશે અને કદાચ ભવિષ્યમાં બગ્સ રજૂ કરશે.

રિચ સ્ક્રેન્ટ મુજબ, કોડ આપણો દુશ્મન છે. તે શું લખે છે તે અહીં છે:

“કોડ ખરાબ છે કારણ કે તે સડવાનું શરૂ કરે છે અને તેને સતત જાળવણીની જરૂર પડે છે. નવી સુવિધાઓ ઉમેરવા માટે ઘણીવાર જૂના કોડમાં ફેરફાર કરવાની જરૂર પડે છે. તે જેટલું મોટું છે, તેટલી ભૂલ થવાની સંભાવના વધારે છે અને તે કમ્પાઈલ કરવામાં વધુ સમય લે છે. બીજા ડેવલપરને તે શોધવામાં વધુ સમય લાગે છે. અને જો રિફેક્ટરિંગની જરૂર હોય, તો ચોક્કસપણે એવા ટુકડાઓ હશે જે બદલવા યોગ્ય છે. મોટા કોડનો અર્થ ઘણીવાર પ્રોજેક્ટની સુગમતા અને કાર્યક્ષમતામાં ઘટાડો થાય છે. એક સરળ અને ભવ્ય ઉકેલ જટિલ કોડ કરતાં ઝડપી છે.

કોડ ક્યારે ન લખવો તે તમે કેવી રીતે જાણો છો?

સમસ્યા એ છે કે પ્રોગ્રામરો ઘણીવાર તેમની એપ્લિકેશનની જરૂરિયાતોની સંખ્યાને અતિશયોક્તિ કરે છે. પરિણામે, કોડના ઘણા વિભાગો અપૂર્ણ રહે છે અથવા કોઈ તેનો ઉપયોગ કરતું નથી, પરંતુ તે એપ્લિકેશનને જટિલ બનાવે છે.

તમારે સ્પષ્ટપણે સમજવું જોઈએ કે તમારા પ્રોજેક્ટને શું જોઈએ છે અને શું નથી.

ઉદાહરણ એ એક એપ્લિકેશન છે જે ફક્ત એક જ કાર્યને ઉકેલે છે - ઇમેઇલનું સંચાલન કરવું. આ હેતુ માટે, બે કાર્યો રજૂ કરવામાં આવ્યા છે - પત્રો મોકલવા અને પ્રાપ્ત કરવા. તમારે એક જ સમયે મેઇલ મેનેજર ટાસ્ક મેનેજર બનવાની અપેક્ષા રાખવી જોઈએ નહીં.

એપ્લિકેશનના મુખ્ય કાર્ય સાથે સંબંધિત ન હોય તેવી સુવિધાઓ ઉમેરવા માટેની દરખાસ્તોને તમારે નિશ્ચિતપણે "ના" કહેવાની જરૂર છે. આ બરાબર તે ક્ષણ છે જ્યારે તે સ્પષ્ટ થઈ જાય છે કે વધારાના કોડની જરૂર નથી.

તમારી એપ્લિકેશનનું ધ્યાન ક્યારેય ગુમાવશો નહીં.

હંમેશા તમારી જાતને પૂછો:

- હવે કયું કાર્ય અમલમાં મૂકવું જોઈએ?
- મારે કયો કોડ લખવો જોઈએ?

મનમાં આવતા વિચારોને પ્રશ્ન કરો અને બહારથી આવતા સૂચનોનું મૂલ્યાંકન કરો. નહિંતર, વધારાનો કોડ ફક્ત પ્રોજેક્ટને મારી શકે છે.

બિનજરૂરી વસ્તુઓ ક્યારે ન ઉમેરવી તે જાણવું તમને તમારા કોડ બેઝને મજબૂત નિયંત્રણમાં રાખવામાં મદદ કરશે.

પાથની ખૂબ જ શરૂઆતમાં, પ્રોગ્રામર પાસે ફક્ત બે અથવા ત્રણ સ્રોત ફાઇલો છે. તે સરળ છે. એપ્લિકેશનને કમ્પાઇલ કરવા અને લોન્ચ કરવા માટે ઓછામાં ઓછો સમય જરૂરી છે; તે હંમેશા સ્પષ્ટ છે કે ક્યાં અને શું જોવું.

જેમ જેમ એપ્લિકેશન વિસ્તરે છે, તેમ તેમ વધુને વધુ કોડ ફાઇલો દેખાય છે. તેઓ કેટલોગ ભરે છે, દરેક સેંકડો લીટીઓ સાથે. આ બધું યોગ્ય રીતે ગોઠવવા માટે, તમારે વધારાની ડિરેક્ટરીઓ બનાવવી પડશે. તે જ સમયે, યાદ રાખવું કે કયા કાર્યો કયા અને કયા કાર્યો માટે જવાબદાર છે તે વધુને વધુ મુશ્કેલ બની રહ્યું છે; ભૂલોને પકડવામાં પણ વધુ સમય લાગે છે. પ્રોજેક્ટ મેનેજમેન્ટ પણ વધુ જટિલ બની રહ્યું છે; દરેક વસ્તુનો ટ્રૅક રાખવા માટે એક નહીં, પરંતુ ઘણા વિકાસકર્તાઓની જરૂર છે. તદનુસાર, ખર્ચ, નાણાકીય અને સમય બંને વધે છે, અને વિકાસ પ્રક્રિયા ધીમી પડે છે.

પ્રોજેક્ટ આખરે વિશાળ બને છે, અને દરેક નવી સુવિધા ઉમેરવા માટે વધુ અને વધુ પ્રયત્નો લે છે. ખૂબ જ નજીવી વસ્તુ માટે પણ તમારે ઘણા કલાકો પસાર કરવા પડશે. હાલની ભૂલો સુધારવાથી નવી ભૂલો દેખાય છે, અને એપ્લિકેશન રીલીઝની સમયમર્યાદા ચૂકી જાય છે.

હવે અમારે પ્રોજેક્ટના જીવન માટે લડવું પડશે. શા માટે?

હકીકત એ છે કે તમે ફક્ત સમજી શક્યા નથી કે તમારે ક્યારે વધારાનો કોડ ઉમેરવો જોઈએ નહીં, અને દરેક સૂચન અને વિચાર માટે "હા" નો જવાબ આપ્યો. તમે અંધ હતા, નવી વસ્તુઓ બનાવવાની ઇચ્છાએ તમને મહત્વપૂર્ણ તથ્યોની અવગણના કરી.

હોરર મૂવી સ્ક્રિપ્ટ જેવું લાગે છે, બરાબર ને?

જો તમે હા કહેતા રહેશો તો આ જ થશે. કોડ ક્યારે ઉમેરવો જોઈએ નહીં તે સમજવાનો પ્રયાસ કરો. પ્રોજેક્ટમાંથી બિનજરૂરી વસ્તુઓ દૂર કરો - આ તમારા જીવનને ઘણું સરળ બનાવશે અને એપ્લિકેશનનું જીવન લંબાવશે.

"મારા સૌથી વધુ ઉત્પાદક દિવસોમાંનો એક એ હતો જ્યારે મેં કોડની 1000 લાઇન કાઢી નાખી."
- કેન થોમ્પસન.

કોડ ક્યારે ન લખવો તે શીખવું મુશ્કેલ છે. પરંતુ તે જરૂરી છે.

હા, હું જાણું છું કે તમે હમણાં જ વિકાસકર્તાના માર્ગ પર આગળ વધ્યા છો અને કોડ લખવા માંગો છો. તે સારું છે, તે પ્રથમ છાપ ગુમાવશો નહીં, પરંતુ ઉત્સાહને કારણે મહત્વપૂર્ણ પરિબળોની દૃષ્ટિ ગુમાવશો નહીં. અમે અજમાયશ અને ભૂલ દ્વારા બધું સમજ્યા. તમે ભૂલો પણ કરશો અને તેમની પાસેથી શીખશો. પરંતુ જો તમે ઉપરોક્તમાંથી શીખી શકશો, તો તમારું કાર્ય વધુ સભાન બનશે.

બનાવતા રહો, પરંતુ ક્યારે ના કહેવું તે જાણો.

સ્કિલબોક્સ ભલામણ કરે છે:

• ઓનલાઈન કોર્સ લાગુ કર્યો "પાયથોન ડેટા એનાલિસ્ટ".
• ઓનલાઇન કોર્સ "પ્રોફેશન ફ્રન્ટ એન્ડ ડેવલપર".
• એક વર્ષનો પ્રેક્ટિકલ કોર્સ "0 થી PRO સુધી PHP વિકાસકર્તા".

સોર્સ: www.habr.com