ഗിറ്റ് #0 - സ്വതന്ത്ര സോഫ്റ്റ്‌വെയറുകളുടെ നിർമ്മാണത്തിനും, പ്രസിദ്ധീകരണത്തിനും

ബാലശങ്കർ സി under പരമ്പര on 26 ഡിസംബർ, 2014

നമ്മളിൽ പലരും സ്വന്തം ആവശ്യങ്ങൾക്കോ, ജോലിയുടെ ഭാഗമായോ ഒക്കെ സോഫ്റ്റ്‌വെയറുകൾ നിർമ്മിച്ചിട്ടുണ്ടാകും. സോഫ്റ്റ്‌വെയർ ഡെവലപ്മെന്റിന്റെ ഇടയിൽ സംഭവിക്കുന്ന ഒരു സാധാരണ പ്രശ്നമാണ്, സോഫ്റ്റ്‌വെയർ കൂടുതൽ മികച്ചതാക്കുന്നതിനു് വേണ്ടി ശ്രമിക്കുമ്പോൾ, വൃത്തിയായിട്ട് നേരത്തെ പ്രവർത്തിച്ചിരുന്നതും കൂടി അടിച്ച് പോകുന്നത്. നമ്മളിൽ ഭൂരിഭാഗം പേരും, നന്നായിട്ട് പ്രവർത്തിക്കുന്ന ഒരു പതിപ്പിന്റെ സോഴ്സ് ഫയലിൽ തന്നെ ഇട്ട് പണിയും. അവസാനം എല്ലാം കൂടെ കുളമായി ഉണ്ടായിരുന്നതും കൂടെ പോയിക്കിട്ടും. ഇത് മറികടക്കാനുള്ള ഒരു എളുപ്പവഴി, നിശ്ചിത സമയങ്ങൾ ഇടവിട്ട്, കോഡിന്റെ ഒരു ബാക്കപ്പ് എടുത്തു സൂക്ഷിക്കുക എന്നതാണ്. പക്ഷേ ഒരു വലിയ പ്രൊജക്റ്റിൽ ഇത് എത്രത്തോളം പ്രായോഗികമാണ് എന്ന് ഊഹിക്കാവുന്നതേയുള്ളൂ.

വേറൊരു പ്രശ്നം, “സഹകരണപരമായ വികസനം - കൊളാബറേറ്റീവ് ഡെവലപ്മെന്റ്” (Collaborative Development) അഥവാ ഒന്നിൽ കൂടുതൽ ആൾക്കാർ ചേർന്ന് ഒരു സോഫ്റ്റ്‌വെയർ നിർമ്മിക്കുമ്പോൾ ഉണ്ടാവുന്ന “സിങ്കിങ്ങ് (syncing)” പ്രശ്നങ്ങൾ. ഞാനും രണ്ടു കൂട്ടുകാരും ചേർന്ന് ഒരു ആപ്ലിക്കേഷൻ നിർമ്മിക്കുകയാണെന്ന് ഇരിക്കട്ടെ. എന്തെങ്കിലും കാരണവശാൽ ഒരു ഫയൽ ഞങ്ങളിൽ രണ്ടുപേർ ഒരേ സമയം എഡിറ്റ് ചെയ്യുകയാണെങ്കിൽ, രണ്ടും കൂടെ യോജിപ്പിക്കുക എന്നത്, പച്ച മലയാളത്തിൽ പറഞ്ഞാൽ “എട്ടിന്റെ പണി”യാണ്. അല്ലെങ്കിൽ, ഞാൻ എഡിറ്റ് ചെയ്ത് തീരുന്നത് വരെ എന്റെ സുഹൃത്ത് കാത്തിരുന്നിട്ട്, ഞാൻ ചെയ്തു് കഴിഞ്ഞത് അവനു്/അവൾക്ക് കൈമാറണം. എന്നിട്ട് അതിൽ വേണം ബാക്കി പണി എടുക്കാൻ. ഇതും എത്രത്തോളം മിനക്കെട്ട പണിയാണെന്ന് ഊഹിക്കാവുന്നയുള്ളൂ. അപ്പോൾ ഈ രണ്ടു് പ്രശ്നങ്ങൾക്കും, അതായത് വേർഷൻ കണ്ട്രോളിങ്ങ്, കൊളാബറേറ്റീവ് ഡെവലപ്മെന്റ്, നമുക്ക് ഒരു പോംവഴി വേണം.

ഇതിൽ വേർഷൻ കണ്ട്രോളിങ്ങിൽ നമുക്ക് വേണ്ട പ്രത്യേകതകൾ ഇവയൊക്കെയാണ്:

  1. പരിപൂർണ്ണമായ തിരുത്തൽ നാൾവഴി (Edit History)
  2. ഏതൊരു അവസ്ഥയിലേക്കും തിരികെ പോകാനുള്ള കഴിവ്
  3. ഓരോ അവസ്ഥകൾ തമ്മിലുള്ള വ്യത്യാസം കാണാനുള്ള കഴിവ്
  4. നിലവിലുള്ള അവസ്ഥ നഷ്ടപ്പെടാതെ തന്നെ, ഒരു പരീക്ഷണാടിസ്ഥാനത്തിലുള്ള ക്രമീകരണം ലഭിക്കാനുള്ള കഴിവ് (An experimental test bed to try out implementing a new feature,without losing an existing working copy)

കൊളാബറേറ്റീവ് ഡെവലപ്മെന്റിലാണെങ്കിലോ:

  1. ഓരോ പങ്കാളിയുടേയും വിവരങ്ങൾ - അവർ ചെയ്ത കോഡ്, സമയം, വലിപ്പം എന്നിവ
  2. യാന്ത്രികമായുള്ള കൂട്ടിയോജിപ്പിക്കൽ (Automatic Merging) - ഒരേ സമയം ഒന്നിൽ കൂടുതൽ ആൾക്കാർ ഒരേ ഫയൽ തിരുത്തിയാൽ, ബുദ്ധിപൂർവ്വം ആ തിരുത്തലുകൾ യോജിപ്പിക്കൽ
  3. കോഡ് പ്രസിദ്ധീകരിക്കാൻ ഒരു വഴി

ഈ പ്രത്യേകതകൾ ഒക്കെ നൽകുന്ന, നമ്മുടെ ചോദ്യങ്ങൾക്കുള്ള ഒരുത്തരം ലിനക്സ് കേർണലിന്റെ സൃഷ്ടാവായ ലിനസ് ടോർവാൾഡ്സ് നൽകിയിട്ടുണ്ട്. അതിന്റെ പേരാണു് “ഗിറ്റ്”. ഗ്നു സാർവ്വജനിക അനുമതിപത്രത്തിന്റെ കീഴിൽ പ്രസിദ്ധീകരിച്ചിട്ടുള്ള ഒരു സ്വതന്ത്ര വികേന്ദ്രീകൃത പതിപ്പ് കൈകാര്യ ഉപകരണമാണ്(Distributed Version Control System) ഗിറ്റ്. നിലവിലുള്ള വേർഷൻ കണ്ട്രോൾ സിസ്റ്റങ്ങൾ കൊണ്ട് തന്റെ ആവശ്യം നടക്കുന്നില്ലെന്ന് കണ്ടപ്പോൾ ലിനസ് സ്വയം ഒരെണ്ണം നിർമ്മിക്കാമെന്ന് തീരുമാനിക്കുകയും, അപ്രകാരം ജന്മമെടുക്കുകയും ചെയ്തതാണ് ഗിറ്റ്. (As always, a good piece of software is the result of a developer’s personal itch)

Git_logo

ഗിറ്റിനെ പറ്റിയുള്ള ഒരു ലേഖന പരമ്പര തുടങ്ങുകയാണു് സ്വതന്ത്രത്തിൽ. ഏറ്റവും ലളിതമായ ഭാഷയിൽ കാര്യങ്ങൾ പറയുക എന്നതു് മാത്രമാണ് ലേഖകന്റെ ലക്ഷ്യം. അതിനാൽ തന്നെ അച്ചടിഭാഷയിൽ ആയിരിക്കും എന്ന് ഒരു ഉറപ്പും ഉണ്ടാവില്ല. പോരാത്തതിനു് ഈ ലേഖനം ലേഖകന്റെ മനസ്സിലാക്കലിന്റെ പുറത്ത് എഴുതപ്പെടുന്നതാണു്. അതിനാൽ തന്നെ തെറ്റുകൾ ഉണ്ടാവാനുള്ള സാദ്ധ്യത വളരെ കൂടുതലും. അങ്ങനെ എന്തെങ്കിലും കണ്ടാൽ കമന്റ് ആയി ഇടുകയോ, അല്ലെങ്കിൽ വ്യക്തിപരമായി ഈമെയിൽ അയയ്ക്കുകയോ ചെയ്ത് സഹായിക്കണം. ഈമെയിൽ ഐഡി - balasankarc [at] gnome [dot] org.

ആദ്യത്തെ ലേഖനത്തിൽ ഗിറ്റിന്റെ അടിസ്ഥാനങ്ങളെ പരിചയപ്പെടുത്തൽ ആണു്.