Read Time:18 Minute
ലല്ലു ആന്തൂര്‍
എന്തൊക്കെയാണ് ഒരു സോഫ്റ്റ് വെയറിൽ വേണ്ട കാര്യങ്ങൾ എന്നും അത് ഏത് രീതിയിൽ ആണ് നിർമ്മിക്കേണ്ടത് എന്നും നമ്മൾ കണ്ടെത്തി രേഖപ്പെടുത്തിക്കഴിഞ്ഞു. അടുത്ത ഘട്ടം ഈ ബ്ലൂ പ്രിന്റ് ഉപയോഗിച്ച് സോഫ്റ്റ് വെയർ നിർമ്മിക്കുക എന്നതാണ്. എങ്ങിനെയാണ് ഇത് ചെയ്യുന്നത് എന്ന് നോക്കാം.
ഏത് ഭാഷയിലാണ് പ്രോഗ്രാം എഴുതേണ്ടത് എന്ന് മുന്നേ തീരുമാനിച്ചതാണല്ലോ. ഇനി ആ ഭാഷയിൽ അങ്ങ് എഴുതിയാൽ പോരേ എന്നവും നിങ്ങളുടെ ചിന്ത. എന്നാൽ അത് അത്ര എളുപ്പമുള്ള കാര്യമൊന്നും അല്ല. ഭാഷ അറിയുക എന്നത് മാത്രമല്ല ഇവിടെ പ്രശ്നം. ഭാഷ നല്ല രീതിയിൽ കൈകാര്യം ചെയ്യാനുള്ള നൈപുണ്യം കൂടി വേണം. ഒരു ഭാഷ സംസാരിക്കാൻ പഠിക്കുന്നതും ആ ഭാഷയിൽ കഥ/കവിത എഴുതുന്നതും തമ്മിലുള്ള അതേ വ്യത്യാസം പ്രോഗ്രാമിങ്ങ് ഭാഷയിലും ഉണ്ട്.
പ്രോഗ്രാമിങ്ങ് ഭാഷയും സംസാര ഭാഷയും തമ്മിൽ ഒരു താരതമ്യം ആയാലോ? ഒരു സംസാര ഭാഷയുടെ ഏറ്റവും അടിസ്ഥാന ഘടകം അക്ഷരങ്ങളാണല്ലോ. അതുപോലെ പ്രോഗ്രാമിങ്ങ് ഭാഷയുടെ അടിസ്ഥാന ഘടകത്തെ ലിറ്ററൽ എന്നാണ് വിളിക്കുക. A, B, …, Z വരെ ഉള്ള എല്ലാ അക്ഷരങ്ങളും (വലിയക്ഷരവും ചെറിയക്ഷരവും) 0, 1, …, 9 വരെ ഉള്ള എല്ലാ അക്കങ്ങളും !, @ തുടങ്ങിയ എല്ലാ ചിഹ്നങ്ങളും പ്രോഗ്രാമിങ്ങ് ഭാഷയിലെ ലിറ്ററലുകൾ ആണ്. അക്ഷരങ്ങൾ ചേർത്തുവച്ച് വാക്കുകൾ ഉണ്ടാക്കുന്നതുപോലെ ലിറ്ററലുകൾ ചേർത്തുവച്ചാൽ കിട്ടുന്നവയാണ് ടോക്കണുകൾ. വാക്കുകളിൽ നാമവും ക്രിയയും നാമവിശേഷണവും ക്രിയാവിശേഷണവും ഒക്കെ ഉള്ളതുപോലെ ടോക്കണുകൾക്കും ഉണ്ട് തരം തിരിവ്. പ്രോഗ്രാമിങ്ങ് ഭാഷ പ്രത്യേകം റിസർവ് ചെയ്ത് വച്ചിരിക്കുന്ന ചില വാക്കുകളെ “കീ വേഡ്” എന്നു വിളിക്കുന്നു. C, Java, Python തുടങ്ങിയ ഭാഷകളിൽ for, while, int, float, return തുടങ്ങിയ വാക്കുകൾ കീ വേഡുകളാണ്. പ്രോഗ്രാമിൽ എവിടെ എപ്പോൾ വന്നാലും ഒരേ വ്യാഖ്യാനം ഉള്ള ടോക്കണുകളാണ് ഇവ. “നാമ”ത്തിനു സമാനമായി പേരിടാൻ ഉപയോഗിക്കുന്ന ടോക്കണുകളാണ് “ഐഡന്റിഫയറുകൾ”. “ക്രിയ”ക്ക് സമാനമായവയെ “ഓപ്പറേറ്റർ” എന്നും വിളിക്കുന്നു. ഒരു ഓപ്പറേഷനെ സൂചിപ്പിക്കാൻ ഉപയോഗിക്കുന്നു എന്നതുകൊണ്ടാണ് ഈ പേര്. +, -, /, =, >, < തുടങ്ങിയവയാണ് ഓപ്പറേറ്ററുകൾ. അക്ഷരങ്ങൾ ചേർന്നാൽ വാചകമായി. പ്രോഗ്രാമിങ്ങ് ഭാഷയിലെ വാചകങ്ങളെ “സ്റ്റേറ്റ്മെന്റ്” എന്നാണ് പറയുക. ഏതൊരു ഭാഷയിലേയും എന്നപോലെ പ്രോഗ്രാമിങ്ങ് ഭാഷക്കും ഒരു വ്യാകരണം ഉണ്ട്. അതിനെ “ഗ്രാമർ” എന്നു തന്നെയാണ് വിളിക്കാറ്. ഒരു വാചകത്തിൽ ഏത് രീതിയിലാണ് വാക്കുകൾ ക്രമീകരിക്കേണ്ടത് എന്നതിനു സമാനമായി ഒരു സ്റ്റേറ്റ്മെന്റിൽ ഏത് രീതിയിലാണ് ടോക്കണുകൾ ക്രമീകരിക്കേണ്ടത് എന്ന് ഈ ഗ്രാമർ പറയും.
ഏതൊരു പ്രോഗ്രാമിങ്ങ് ഭാഷയിലേയും ഏറ്റവും ലളിതമായ പ്രോഗ്രാമിനെയാണ് “ഹലോ വേൾഡ്” പ്രോഗ്രാം എന്ന് പറയുന്നത്. അറിയപ്പെടുന്ന എല്ലാ ഭാഷകളിലും ആ പ്രോഗ്രാം എങ്ങിനെ എഴുതണം എന്ന് ഇവിടെ കാണാം. ഏറ്റവും ലളിതമായ പൈത്തൺ മുതൽ രസകരമായ കൗ (cow) വരെ എല്ലാ ഭാഷകളിലും ഉള്ള ഹലോ വേൾഡ് പ്രോഗ്രാമുകൾ ഇതിലുണ്ട്. ഏതെങ്കിലും ഒരു ഭാഷ കൂടുതലായി പഠിക്കണമെങ്കിൽ നൂറുകണക്കിനു ട്യൂട്ടോറിയലുകൾ ഇന്റർനെറ്റിൽ സുലഭം.
കഥ/കവിത തുടങ്ങിയവയിൽ വ്യാകരണത്തിൽ നിന്നും ഒരിത്തിരി വ്യതിചലിക്കുന്നത് അത്ര വല്ല്യ പ്രശ്നമൊന്നും അല്ലല്ലോ. എന്നാൽ പ്രോഗ്രാമിങ്ങ് ഭാഷയിലാവട്ടെ തെല്ലുപോലും ഗ്രാമറിൽ പിശകുവരുത്താൻ പാടില്ല. ഹൈ വോൾട്ടേജും ലോ വോൾട്ടേജും മാത്രം തിരിച്ചറിയാൻ പറ്റുന്ന ഒരു മണ്ടൻ പെട്ടി എങ്ങിനെയാണ് അതിവേഗത്തോടെ അത്യധികം കൃത്യതയോടെ പല ജോലിക്കളും ചെയ്യുന്നത് എന്ന് നിങ്ങൾ എപ്പോഴെങ്കിലും ആലോചിച്ചിട്ടുണ്ടോ? അവിടെയാണ് ഈ കൃത്യതയുടെ ആവശ്യം. എന്ത് ചെയ്യണം എന്നു വ്യക്തമായി പറഞ്ഞുകൊടുത്താൽ മാത്രമേ ഒരു കമ്പ്യൂട്ടറിനു ശരിയായി പ്രവർത്തിക്കാൻ സാധിക്കൂ. അപ്പോൾ ഒന്നിലധികം രീതിയിൽ വ്യാഖ്യാനിക്കാൻ പറ്റുന്ന നിർദ്ദേശങ്ങൾ പാടേ ഒഴിവാക്കിയേ പറ്റൂ. ചുരുക്കിപ്പറഞ്ഞാൽ പ്രോഗ്രാമിങ്ങ് ഭാഷയിൽ ഒരു കവിത എഴുതണമെങ്കിൽ ഗ്രാമർ വിട്ടുള്ള ഒരു ഭാവനയും നടക്കില്ല.
നമ്മുടെ ഫോണിലെ/കമ്പ്യൂട്ടറിലെ പോലെ അക്ഷരപ്പിശകുകൾ/വ്യാകരണപ്പിഴകുകൾ കണ്ടുപിടിക്കാനുള്ള സംവിധാനങ്ങൾ പ്രോഗ്രാമിങ്ങ് ഭാഷയിലും ലഭ്യമാണ്. അത് കൂടാതെ എഴുതിയ പ്രോഗ്രാമുകൾ പ്രവർത്തിപ്പിച്ച് നോക്കാനും ഓരോ ഘട്ടത്തിലും എന്തൊക്കെയാണ് സംഭവിക്കുന്നത് എന്ന് അറിയാനും ഒക്കെ ഉള്ള സൂത്രപ്പണികളും ലഭ്യമാണ്. ഇത്തരത്തിലുള്ള സൂത്രങ്ങൾ കൂടിച്ചേർന്ന പ്രോഗ്രാമുകളെയാണ് IDE(Integrated Development Environment) എന്നു പറയുന്നത്. എക്ലിപ്സ്, ഇന്റലി-ജെ ഐഡിയ, മൈക്രോസോഫ്റ്റ് വിഷ്വൽ സ്റ്റുഡിയോ കോഡ് തുടങ്ങിയവ ഉദാഹരണങ്ങൾ. അക്ഷരപ്പിശകില്ലാതെ ശരിയായ വ്യാകരണത്തോടെ എഴുതിയാൽ മാത്രം നല്ല ഒരു പ്രോഗ്രാം ഉണ്ടാവില്ല. അതിനു ഭാഷയുടെ മറ്റു നിയമങ്ങൾ കൂടി പാലിക്കണം. പറയാനുള്ള കാര്യങ്ങൾ എല്ലാം ഒറ്റ അടിക്ക് പറയുന്നതിന് പകരം അതിനെ ചിട്ടയായി അടുക്കി അധ്യായങ്ങളാക്കിയാൽ വായിക്കൻ എളുപ്പമുണ്ടാകുമല്ലോ. അതുപോലെ പരസ്പര ബന്ധമില്ലാത്ത കാര്യങ്ങൾ ഒരേ അധ്യായത്തിൽ പറയുന്നതും പരസ്പരം ബന്ധപ്പെട്ടിരിക്കുന്ന കാര്യങ്ങൾ വിവിധ അധ്യായങ്ങളിലായി പറയുന്നതും നല്ല രീതി അല്ലല്ലോ. ഇത്തരം പ്രത്യേകതകൾ പ്രോഗ്രാമിങ്ങ് ഭാഷക്കും ബാധകമാണ്. ഇത്തരത്തിൽ നല്ല രീതിയിൽ കമ്പ്യൂട്ടറിനോടുള്ള നിർദ്ദേശങ്ങൾ ക്രമീകരിക്കാനുള്ള ചട്ടക്കൂടുകളെ പൊതുവായി design pattern എന്നാണ് വിളിക്കാറ്. സാഹചര്യത്തിനനുസരിച്ച് അനുയോജ്യമായ ഇത്തരം design pattern തിരഞ്ഞെടുക്കാനും പ്രയോഗിക്കനും ഉള്ള കഴിവും ഒരു പ്രോഗ്രാമർക്ക് അനിവാര്യമാണ്. ഇത് കൂടാതെ DRY, KISS, SOLID എന്നിങ്ങനെ വിവിധ തത്വങ്ങളും ഒരു പ്രോഗ്രാമർ അറിഞ്ഞിരിക്കേണ്ടതുണ്ട്.
ഒരു സോഫ്റ്റ് വെയർ എഴുതുമ്പോൾ ശ്രധിക്കേണ്ട മറ്റൊരു കാര്യം സഹപ്രവർത്തകർക്ക് കൂടി മനസിലാവുന്ന രീതിയിൽ എഴുതുക എന്നതാണ്. ഒരു ഭാഗം എഴുതി തയാറാക്കുന്നയാൾ ആയിരിക്കില്ല ഒന്നോ രണ്ടോ മാസത്തിനു ശേഷം അതേ ഭാഗത്ത് മറ്റൊരു മാറ്റം വരുത്താൻ നോക്കുക. അപ്പോൾ പുതിയൊരു വ്യക്തിക്ക് എളുപ്പം മനസിലാവുന്ന രീതിയിൽ വേണം പ്രോഗ്രാമുകൾ എഴുതാൻ. അതി സങ്കീർണമായ കാര്യങ്ങൾ ചെയ്യേണ്ടിവരികയാണെങ്കിൽ അതിനെക്കുറിച്ചുള്ള ഒരു കുറിപ്പ് പ്രോഗ്രാമിനൊപ്പം ചേർക്കുന്ന രീതിയും നിലനിൽക്കുന്നു. ഇത്തരം കുറിപ്പുകളെ comments എന്നാണ് പറയുക.
ഏതൊരു കാര്യം ചെയ്യുമ്പോഴും തെറ്റ് പറ്റാനുള്ള സാധ്യത തള്ളിക്കളയാനാവില്ല. ഒരു സോഫ്റ്റ് വെയറിൽ ഒരു തെറ്റ് പറ്റിക്കഴിഞ്ഞാൽ അത് ഒരുപാട് ബുദ്ധിമുട്ടുകൾ ഉണ്ടാക്കും. അതിനാൽ പറ്റാവുന്നത്ര തെറ്റുകൾ തുടക്കത്തിലേ കണ്ടുപിടിക്കുക എന്ന രീതിയാണ് പ്രോഗ്രാമിങ്ങിൽ അവലംബിക്കുന്നത്. ഇത്തരത്തിൽ തെറ്റുകൾ കണ്ടുപിടിക്കാൻ എഴുതുന്ന കുഞ്ഞൻ പ്രോഗ്രാമുകൾ ആണ് ടെസ്റ്റുകൾ. ഒരു പ്രോഗ്രാമിന്റെ ഏറ്റവും ചെറിയ ഘടകം മുതൽ മുഴുവൻ സോഫ്റ്റ് വെയർ വരെ പരിശോധിക്കാവുന്ന രീതിയിൽ നമുക്ക് ടെസ്റ്റുകൾ എഴുതാം. അതായത് പ്രോഗ്രാമിങ്ങ് ഭാഷയിലെ ഒരു ചെറിയ ഖണ്ഡിക മുതൽ ഒരു മഹാകാവ്യം വരെ നമുക്ക് ടെസ്റ്റ് ചെയ്യാൻ കഴിയും. കഴിയണം. വാഹന നിർമ്മാണത്തിലെ ഇത്തരം ക്വാളിറ്റി അഷൂറൻസ് പ്രക്രിയകളെക്കുറിച്ച് നിങ്ങൾ കേട്ടിട്ടുണ്ടാകുമല്ലോ. ഇവിടെയും ഇതിന് ക്വാളിറ്റി അഷൂറൻസ് എന്ന് തന്നെ പേര്. ഒരു പ്രോഗ്രാമിനോട് ആരെങ്കിലും ഒരു അധ്യായം കൂട്ടിച്ചേർക്കുകയോ, ഏതെങ്കിലും അധ്യായങ്ങളിൽ തിരുത്തൽ വരുത്തുകയോ ചെയ്താൽ അതിന്റെ കൂടെ അതിന്റെ ടെസ്റ്റ് കൂടെ ചേർക്കുക എന്നത് സ്വാഭാവികമായ ഒരു നടപടി ആണ്. വ്യക്തമായ ടെസ്റ്റ് ഇല്ലാതെ ഒരു പ്രോഗ്രാമിൽ മാറ്റം വരുത്താൻ ആരേയും അനുവദിക്കാറില്ല.
പ്രോഗ്രാമുകൾ എഴുതുന്നത് സോഫ്റ്റ് വെയർ എഞ്ചിനീയർ അല്ലെങ്കിൽ സോഫ്റ്റ് വെയർ ഡെവലപ്പർ എന്ന വിഭാഗത്തിലുള്ളവരാണ്. സോഫ്റ്റ് വെയർ മേഖലയിൽ തുടക്കമിടുന്നവർ മുതൽ ഏകദേശം 10 വർഷം വരെ പരിചയമുള്ളവരാണ് ഈ വിഭാഗത്തിൽ വരുന്നത്. ഏതൊരു സോഫ്റ്റ് വെയർ കമ്പനി എടുത്താലും അവിടെ ഉള്ള ജോലിക്കാരിൽ 60% പേരും ഇത്തരക്കാരാവും. ഈ കൂട്ടർ തന്നെ ആവും പകുതിയോളം ടെസ്റ്റുകളും എഴുതുക. ഒരാൾ തന്നെ നിർമ്മാണവും ക്വാളിറ്റി അഷൂറൻസും ചെയ്താൽ ചിലപ്പോൾ തെറ്റുകൾ ശ്രധിക്കപ്പെടാതെ പോവാനുള്ള സാധ്യത ഉണ്ട്. അതിനാൽ ഇത് ടെസ്റ്റ് ചെയ്യുക എന്ന ലക്ഷ്യം മാത്രം ഉള്ള ജീവനക്കാരും ഉണ്ട്. അവരെ Q, QA, Quality തുടങ്ങിയ ഓമനപ്പേരുകളിട്ടാണ് വിളിക്കാറ്. ഇവരുടെ ജോലി നമ്മൾ മുൻ കൂട്ടി തയാറാക്കിയ റിക്വയർമെന്റുമായി പ്രോഗ്രാമിനെ ഒത്തുനോക്കുക എന്നതാണ്. എവിടെയെങ്കിലും പാളിച്ച കണ്ടാൽ അത് യധാസമയം പ്രോഗ്രാമർമാരെ അറിയിക്കുകയും വേണം.
ഒരു വലിയ സോഫ്റ്റ് വെയറിനെ ചെറിയ ഘടകങ്ങളാക്കിയാണ് നിർമ്മിക്കുക എന്ന് നേരത്തെ പറഞ്ഞിരുന്നല്ലോ. ഇത്തരം ഘടകങ്ങൾ പൊതുവേ വിവിധ ടീമുകളാണ് നിർമിക്കുക. ഇത്തരം കുഞ്ഞൻ ടീമുകളെ സ്ക്രം ടീം (scrum team) എന്നാണ് വിളിക്കുക. ഈ ടീമിന്റെ ലീഡറെ സ്ക്രം മാസ്റ്റർ എന്നും വിളിക്കും. കൂട്ടത്തിൽ മുതിർന്ന ഡെവലപ്പർമാരാകും ഈ പദവി കൈകാര്യം ചെയ്യുക. വിവിധ ടീമുകൾ തമ്മിലുള്ള ആശയവിനിമയവും ആശ്രിത വിഷയങ്ങളുടെ ആസൂത്രണവും ചെയ്യുന്നത് ഇവരായിരിക്കും. ആദ്യമേ തയാറാക്കിവച്ച യൂസർ സ്റ്റോറികളും എപ്പിക്കുകളും ആരൊക്കെ എപ്പോഴൊക്കെ ആണ് ചെയ്യണ്ടത് എന്നും ഇവർ കൂടിച്ചേർന്നാണ് തീരുമാനിക്കുക. പൊതുവെ ജോലി പ്ലാൻ ചെയ്യുമ്പോൾ ഒന്ന് അല്ലെങ്കിൽ രണ്ട് ആഴ്ച നീളമുള്ള സ്പ്രിന്റുകളായാണ് ജോലി വിഭജിക്കുക. ഈ കാലയളവിൽ ചെയ്യാൻ സാധിക്കുന്ന കാര്യങ്ങൾ ഏറ്റെടുക്കുകയും ചിട്ടയായി ചെയ്യുകയും ആണ് പതിവ്. പരസ്പരാശ്രയത്വം നല്ലരീതിയിൽ കൈകാര്യം ചെയ്യാനും പെട്ടന്നു വരുന്ന മാറ്റങ്ങൾ ബുദ്ധിമുട്ടില്ലാതെ മാനേജ് ചെയ്യാനും ഇത് സഹായിക്കുന്നു. ഇങ്ങനെ സ്ക്രം ടീം ആയി ജോലി ചെയ്യുന്ന രീതിയെ അജൈൽ സോഫ്റ്റ് വെയർ എഞ്ചിനീയറിങ്ങ് എന്നു വിളിക്കുന്നു.
വിവിധ ടീമുകളായി നിരവധി പ്രോഗ്രാമർമാർ ഒരു സോഫ്റ്റ് വെയർ നിർമ്മിക്കുമ്പോൾ ഈ പ്രോഗ്രാം ഏത് രീതിയിൽ ആയിരിക്കും സ്റ്റോർ ചെയ്യുക? ഒരു ഇടത്തരം സോഫ്റ്റ് വെയർ തന്നെ നൂറുകണക്കിന് ഫയലുകൾ ചേർന്നതാവും. അതിൽ പല ഫയലുകളിലും നിരവധി പേർ ഒരുമിച്ച് മാറ്റം വരുത്തുന്നുമുണ്ടാവാം. അപ്പോൾ ഒരാൾ മറ്റൊരാളുടെ മാറ്റങ്ങൾ ഒവർ റൈറ്റ് ചെയ്യാനുള്ള സാധ്യതയുമുണ്ട്. ഇത് മറികടക്കാനാണ് ഗിറ്റ്, സബ് വെർഷൻ, മെർക്കുറിയൽ തുടങ്ങിയ വെർഷൻ കണ്ട്രോൾ ടൂളുകൾ ഉപയോഗിക്കുന്നത്. നിരവധി പേർക്ക് ഒരേ സമയം ഒരേ ഫയലിൽ ഒരു പ്രശ്നവുമില്ലാതെ മാറ്റം വരുത്താൻ ഇത്തരം ടൂളുകൾ സഹായിക്കുന്നു. കൂടാതെ ഒരു പ്രോഗ്രാമർ വരുത്തുന്ന മാറ്റങ്ങൾ മറ്റോരാൾ കൂടി കണ്ട് ഒരു പിയർ റിവ്യൂ നടത്താനും ഇത്തരം ടൂളുകൾ സഹായിക്കുന്നു.
പ്രോഗ്രാമിനും ടെസ്റ്റിനും പുറമേ ഒരു പ്രധാന ഘടകം കൂടി എല്ലാ സോഫ്റ്റ് വെയർ കമ്പനികളിലും ഉണ്ടാവും. അതാണ് ഓട്ടോമേഷൻ. പത്തോ നൂറോ ആളുകൾ വരുത്തുന്ന മാറ്റങ്ങൾ എല്ലാം മറ്റൊരാൾ (ഒരു കൂട്ടം ആൾക്കാർ) ഇരുന്നു പൂർണ്ണമായും ടെസ്റ്റ് ചെയ്യുക അസാധ്യമാണ്. അതിനാൽ ഇത്തരം സാഹചര്യത്തിൽ മറ്റൊരു ടൂൾ ഉപയോഗിച്ച് ടെസ്റ്റ് ചെയ്യാറാണ് പതിവ്. ഇത്തരത്തിൽ ഓട്ടോമാറ്റിക്കായി ടെസ്റ്റുകൾ ചെയ്യാൻ സഹായിക്കുന്ന സംവിധാനത്തേയാണ് ഓട്ടോമേഷൻ എന്നു പറയുക. ഗിറ്റ് പോലുള്ള വെർഷൻ കണ്ട്രോൾ ടൂളിൽ രേഖപ്പെടുത്തുന്ന മാറ്റങ്ങൾ സ്വയം തിരിച്ചറിയാനും അതിനനുസരിച്ച് വേണ്ടുന്ന ടെസ്റ്റുകൾ നടത്താനും ഫലം തിരിച്ച് ഗിറ്റിനെ അറിയിക്കാനും ഇത്തരം ടൂളുകൾക്കാവും. അതിനായി ഉപയോഗിക്കുന്ന ടൂളുകളാണ് ജെങ്കിൻസ്, ട്രാവിസ് സി ഐ, സർക്കിൾ സി ഐ, കോൺകോഴ്സ് മുതലായവ. ഇത്തരം ടൂളുകളെ പൊതുവേ കണ്ടിന്യുവസ് ഇന്റഗ്രേഷൻ (continuous integration) ടൂളുകൾ എന്നാണ് വിളിക്കുക.
ഇത്തരത്തിൽ നിരവധി ആളുകളുടേയും ടൂളുകളുടേയും നിരന്തര പരിശ്രമഫലമാണ് ഒരു സോഫ്റ്റ് വെയർ. പ്രോഗ്രാമിങ്ങും ടെസ്റ്റിങ്ങും കഴിഞ്ഞ് ഒരു സോഫ്റ്റ് വെയർ ഏതൊക്കെ വഴിക്ക് പോവുന്നു എന്ന് അടുത്ത ലേഖനത്തിൽ വായിക്കാം.
ലേഖനത്തിന്റെ ആദ്യഭാഗങ്ങൾ
- ഒരു സോഫ്റ്റ് വെയർ നിർമ്മിക്കുന്നതെങ്ങനെ ?
- സോഫ്റ്റ്വെയർ എഞ്ചിനീയറിംഗ് പ്രക്രിയ – ഭാഗം 1
- സോഫ്റ്റ്വെയർ എഞ്ചിനീയറിംഗ് പ്രക്രിയ – ഭാഗം 2
- സോഫ്റ്റ്വെയർ എഞ്ചിനീയറിംഗ് പ്രക്രിയ – ഭാഗം 3
Happy
0 %
Sad
0 %
Excited
0 %
Sleepy
0 %
Angry
0 %
Surprise
0 %
0
0
