ഒരു സോഫ്റ്റ്വെയർ പ്രോഗ്രാം നമ്മൾ ഓടിക്കുമ്പോൾ അതിന്റെ flow of execution എന്താണ്.

വളരെ ഇന്ട്രെസ്റ്റിംഗ് ആയിട്ടുള്ള ഈ കോൺസെപ്റ്റ് ഞാൻ ഇപ്പോൾ മനസ്സിലാക്കി.

ഒരു സോഫ്റ്റ്‌വെയർ പ്രോഗ്രാം ഓടിക്കുമ്പോൾ അത് എങ്ങനെയാണ് ഓരോ ഫംഗ്ഷൻസ്, വേരിയബിൾസ് ഇതൊക്കെ റൺ ചെയ്യുന്നത്, അതിൻറെ ഓർഡർ എന്താണ്.

അതിനെക്കുറിച്ച് മനസ്സിലാക്കാനായിട്ട് ഞാൻ സെർച്ച് ചെയ്തപ്പോൾ കിട്ടിയ ഒരു പേജാണിത്.

പ്രോഗ്രാമിംഗ് ചെയ്യുന്ന എല്ലാവരും അറിഞ്ഞിരിക്കേണ്ട ഒരു ഇൻഫർമേഷൻ തന്നെയാണിത്.

നാച്ചുറൽ ആയിട്ട് ഇതിനെക്കുറിച്ച് ഒരു ഐഡിയ, ഊഹം നമുക്ക് നമ്മുടെ ഉള്ളിലുണ്ടാകും,
പക്ഷേ അത് കറക്റ്റ് ആയിട്ട് എങ്ങനെയാണെന്ന് മനസ്സിലാക്കുമ്പോഴാണ് ഒരു കമ്പ്യൂട്ടർ ഏറ്റവും എഫിഷ്യന്റ് ആയിട്ട് ഒരു പ്രോഗ്രാം ഓടിക്കുന്നത് എന്ന് നമുക്ക് മനസ്സിലാക്കാൻ സാധിക്കുന്നത്.

അപ്പോൾ ഈ ഫ്ലോ ഓഫ് എക്സിക്യൂഷൻ എങ്ങനെയാണ് വർക്ക് ആവുന്നത് നമുക്ക് നോക്കാം.

ഒരു പ്രോഗ്രാം run ചെയ്യുമ്പോൾ അതിൻറെ എക്സിക്യൂഷൻ ഏറ്റവും മുകളിൽ നിന്നാണ് തുടങ്ങുന്നത് പിന്നെ ഓരോ ഓരോ സ്റ്റെപ്പായി, line by line താഴെക്കാണ് പോകുന്നത്.

ഒരു സമയത്ത് ഒരു വരി മാത്രമാണ് എക്സിക്യൂട്ട് ആകുന്നത്.

ഫംഗ്ഷൻ ഡിഫൈൻ(function definition) ചെയ്ത ഭാഗം സ്കിപ്പ് ചെയ്താണ് താഴേക്ക് പോകുന്നത്.

അതേസമയം അങ്ങനെ ഒരു ഫംഗ്ഷൻ അവിടെ ഡിഫൈൻ ചെയ്തിട്ടുണ്ടെന്നുള്ള കാര്യം നോട്ട് ചെയ്യുകയും ചെയ്യുന്നുണ്ട്

എന്നാൽ ഫംഗ്ഷൻ ഉള്ളിൽ നടക്കുന്ന സംഭവങ്ങൾ അത് റൺ ചെയ്യുന്നില്ല അത് ഫംഗ്ഷനിൽ വിളിക്കുമ്പോൾ മാത്രമാണ് അത് എക്സിക്യൂട്ട് ചെയ്യുന്നത്,

അതായത് ഫംഗ്ഷൻ ഡെഫിനിഷൻ സ്കിപ്പ് ചെയ്തു പോവുകയാണ്.

ഫങ്ക്ഷനെ വിളിക്കുന്ന സമയത്ത് നേരെ ഒരു ഫങ്ഷന്റെ അകത്തുള്ള സംഭവങ്ങൾ എക്സിക്യൂട്ട് ചെയ്തിട്ട് തിരിച്ച് വിളിച്ച സ്ഥാനത്ത് വന്നിട്ട് അടുത്ത സ്റ്റെപ്പിലേക്ക്, അതായത് അതിന്റെ തൊട്ടു താഴെയുള്ള ലൈനിലേക്ക് എക്സിക്യൂട്ടീവ് ചെയ്യാൻ വേണ്ടി പോവുകയാണ് ചെയ്യുന്നത്.

ചുരുക്കിപ്പറഞ്ഞാൽ മേളിൽ നിന്ന് താഴേക്ക് ലൈൻ ആയിട്ട് വരുന്നു. ഫംഗ്ഷൻ ഡെഫിനിഷൻ ഒഴിവാക്കുന്നു ഫംഗ്ഷൻ കോൾ ചെയ്യുമ്പോൾ അങ്ങോട്ട് പോകുന്നു തിരിച്ചുവരുന്നു.

വീണ്ടും അടുത്ത ലൈനിലേക്ക് പോകുന്നു ഇങ്ങനെ നോക്കുമ്പോൾ വളരെ സിമ്പിൾ ആയിട്ട് തോന്നും പക്ഷേ നമ്മൾ മനസ്സിലാക്കേണ്ട - കാര്യം ഒരു ഫങ്ക്ഷന് മറ്റൊരു ഫംഗ്ഷനെ വിളിക്കാൻ സാധിക്കും - അപ്പോൾ ആ വഴിക്ക് ഇങ്ങനെ പോയി പോയി മറ്റ് പല സ്ഥലത്തും പോയി എക്സിക്യൂട്ട് ചെയ്തിട്ടായിരിക്കും അടുത്ത ലൈനിലേക്ക് തിരിച്ചു വരിക.

ഇതിൽനിന്നും നമ്മൾ മനസ്സിലാക്കേണ്ട കാര്യം നമ്മൾ വായിക്കുമ്പോൾ മുകളിൽ നിന്ന് താഴേക്ക് വായിക്കുക, മൊത്തം താഴേക്ക് വായിച്ചു പോകുന്നതിനു പകരം -

ആ ഫ്ലോ ഓഫ് എക്സിക്യൂഷൻ പോകുന്ന വഴിയെ നമ്മളും പോയി കഴിഞ്ഞാൽ - നമുക്ക് കൃത്യമായിട്ട് ആ ഒരു ലോജിക്ക് മനസ്സിലാകുന്നതാണ്.

നമുക്ക് ഒരു ഫങ്ഷൻ വിളിക്കുന്ന സമയത്ത് ആ ഫങ്ങ്ഷനിലേക്ക് പോയി അവിടെ നിന്ന് കിട്ടുന്ന റിസൾട്ടുമായി തിരിച്ചുവന്ന് അടുത്ത ലൈൻ വായിക്കുക.

ഇപ്പോൾ നമ്മൾ മനസ്സിലാക്കിയ കാര്യം കൃത്യമാണോ എന്ന് ടെസ്റ്റ് ചെയ്യാനായിട്ട് അടിപൊളി എക്സാമ്പിൾ നമുക്ക് കാണാം.

def pow(b, p):
    y = b ** p
    return y

def square(x):
    a = pow(x, 2)
    return a

n = 5
result = square(n)
print(result)

Steps - . 1, 5, 9, 10, 5, 6, 1, 2, 3, 6, 7, 10, 11