செயல்பாட்டு நிரலாக்க அடிப்படைகள் – பகுதி 1

இதுநாள்வரையில் பொருள்நோக்குநிரலாக்கத்தைப் (object oriented programming) பயன்படுத்தியே நிரலெழுதி வருவோர், செயல்பாட்டு நிரலாக்கத்தைக் (functional programming) கற்றுக்கொள்ளவேண்டுமென்றால் அதன் அடிப்படைக்கருத்துக்களை அறிந்துகொள்ளவேண்டியது அவசியம். முதலில் இது சற்றே கடினமான விசயமாகத்தெரிந்தாலும், சரியான கோணத்திலிருந்து அணுகும்போது எளிமையானதாகவே இருக்கிறது.

முதன்முதலில் ஒரு வாகனத்தை ஓட்டக்கற்றுக்கொள்ளும்போது மிகவும் சிரமப்பட்டு கற்றுக்கொள்கிறோம். பிறர் செய்வதைக்காணும்போது எளிமையாகத்தோன்றினாலும், நாமே செய்யும்போது நாம் நினைத்ததைவிட கடினமானதாகவே இருந்தது. மிதிவண்டியை வாடகைக்கு எடுத்துக்கொண்டு, அக்கம்பக்கத்து தெருக்களில் சுற்றித்திரிந்து பழகுகிறோம். பலமுறை விழுந்தெழுந்து, முட்டிமோதி சைக்கிள் ஓட்டக்கற்றுக்கொண்டுவிட்டோம்.

அதன்பிறகு சொந்தமாக சைக்கிள் வாங்கி ஓட்டுவதோ, அல்லது இருசக்கரவாகனத்தை ஓட்டப்பழகுவதோ, முதன்முறை சைக்கிளோட்டக்கற்றுக்கொண்டதைப்போல அவ்வளவு சிரமமாக இருப்பதில்லை. மேலும் அன்றாடம் பயன்படுத்திக்கொண்டிருந்தால் வாகனமோட்டுவதில் கைதேர்ந்தவர்களாகவும் ஆகிவிடுகிறோம்.

ஆனால், ஒரு விண்கலத்தைச் செலுத்தநேரும்போது, இந்த அனுபவமெதுவும் நமக்குப்பயன்தராது. ஆகச்சிறந்த சாலைகளில், மிகப்பெரிய வாகனங்களை எத்தனைமுறை இயக்கியிருந்தாலும் பயனில்லை. விண்கலத்தை இயக்கவேண்டுமெனில், மீண்டும் பூச்சியத்திலிருந்து தொடங்கி அனைத்தையும் கற்றுக்கொள்ளவேண்டும்.

பல்வேறு நிரலாக்கமொழிகளைக்கற்றுக்கொள்வதும் இதுபோலவே இருக்கிறது. முதல்மொழியைக் கற்றுத்தேர்ந்தபின்னர் பிறமொழிகளைக் கற்றுக்கொள்வது கடினமாக இருப்பதில்லை. “கூறுகளை (module) வரையறுப்பதெப்படி? தொகுப்புகளைக் (collections) கையாளுவதெப்படி? செங்கோவைகளை (Regex) எப்படி பயன்படுத்தலாம்?” என்பதுபோன்ற ஒருசில கேள்விகள் மட்டுமே எஞ்சும்.

ஆனால், எத்தனை பொருள்நோக்கு நிரலாக்கமொழிகளைக் கற்றிருந்தாலும், செயல்பாட்டு நிரலாக்கத்தைக்கற்றுக்கொள்ளும்போது அடிப்படைக்கருத்துக்களனைத்தையும் வேறொருகோணத்திலிருந்து கற்றுக்கொள்ளவேண்டும்.

ஏற்கனவே கற்றுக்கொண்ட அனைத்தையும் மறந்துவிட்டு புதிதாகத்தொடங்கலாம். நிதானமாக ஒவ்வொரு கருத்தையும், எடுத்துக்காட்டையும்புரிந்துகொள்வது அவசியம்.

தூய்மை:

செயல்பாட்டு நிரலாக்கத்தின் செயற்கூறுகள், தூய்மையான செயற்கூறுகளாக இருக்கவேண்டும். தூய்மையான செயற்கூறுகளுக்கென்று சில பண்புகள் உள்ளன. அவற்றை ஒவ்வொன்றாகப் பார்க்கலாம்.

தூய்மையான செயற்கூறுகள், தனது உள்ளீட்டு உருபுகளைக்கொண்டு மட்டுமே இயங்கவேண்டும்.

[code lang=”javascript”]
var z = 10;
function add(x, y) {
return x + y;
}
[/code]

இங்கே, add என்ற செயற்கூறு அதற்குக்கொடுக்கப்பட்ட x, y என்ற உள்ளீட்டு உருபுகளை மட்டுமே பயன்படுத்துகிறது. வெளியே வரையறுக்கப்பட்ட z என்ற மாறியைப் பயன்படுத்தவில்லை.

வேறொரு செயற்கூற்றை எடுத்துக்கொள்ளலாம்.

[code lang=”javascript”]
function justTen() {
return 10;
}
[/code]

இங்கே justTen என்பது ஒரு தூய்மையான செயற்கூறாகும். ஆனால், உள்ளீட்டு உருபுகள் ஏதும் இல்லாததால், இச்செயற்கூற்றை எப்போது இயக்கினாலும், 10 என்ற மாறிலியை மட்டுமே திருப்பியனுப்புகிறது. உள்ளீட்டு உருபுகளை ஏற்காத செயற்கூறுகள், எந்தவொரு பயனுள்ள வேலையையும் செய்யமுடியாது.

எனவே பயனுள்ள தூய்மையான செயற்கூறுகள் குறைந்தது, ஒரு உள்ளீட்டு உருபையாவது ஏற்கவேண்டும்.

[code lang=”javascript”]
function addNoReturn(x, y) {
var z = x + y
}
[/code]

மேற்கண்ட செயற்கூறு எந்தவொரு மதிப்பையும் திருப்பியனுப்பவில்லை. கொடுக்கப்பட்ட உள்ளீட்டு உருபுகளைக் கூட்டி z என்ற மாறியில் சேமித்து வைக்கிறது. ஆனால், அதை திருப்பியனுப்பாததால், இச்செயற்கூற்றால் நமக்கு எந்தவொரு பயனுமில்லை.

எல்லா பயனுள்ள தூய்மையான செயற்கூறுகளும் ஒருமதிப்பைத் திருப்பியனுப்புவது அவசியம்.

நாம் முதலில் எழுதிய add செயற்கூற்றையே எடுத்துக்கொள்வோம்.

[code lang=”javascript”]
function add(x, y) {
return x + y;
}
console.log(add(1, 2)); // மூன்றை அச்சிடுகிறது – 3
console.log(add(1, 2)); // மீண்டும் மூன்றையே அச்சிடுகிறது – 3
console.log(add(1, 2)); // எப்போதுமே மூன்றை மட்டுமே அச்சிடும் – 3
[/code]

ஒன்றையும் இரண்டையும் கூட்டினால் மூன்று என்ற விடை கிடைத்ததில் நமக்கு வியப்பொன்றுமில்லை. இது தூய்மையான செயற்கூறுகளின் மிகமுக்கிய பண்பாகும்.

ஒரே உள்ளீட்டை எத்தனைமுறை கொடுத்தாலும், தூய்மையான செயற்கூறுகளின் வெளியீட்டில் எந்தவொரு மாற்றமுமிருக்கக்கூடாது.

தூய்மையான செயற்கூறுகள் வெளியிலிருக்கும் மாறிகளை அணுகவோ, மாற்றவோ கூடாது என்பதால், பின்வரும் செயற்கூறுகள் தூய்மையற்ற செயற்கூறுகளுக்கு எடுத்துக்காட்டுகளாகும்.

[code lang=”javascript”]
writeFile(fileName);
updateDatabaseTable(sqlCmd);
sendAjaxRequest(ajaxRequest);
openSocket(ipAddress);
[/code]

மேற்கண்ட எல்லா செயற்கூறுகளும் பக்கவிளைவுகள் கொண்டவை. அவற்றை இயக்கும்போது கோப்புகளிலும், தரவுதளத்திலும் மாற்றங்கள் செய்யக்கூடியவை. கொடுக்கப்பட்ட உள்ளீட்டு உருபுகளை வைத்து கணக்கீடுகள் செய்து , மதிப்புகளைத் திருப்பியனுப்புவதோடு, வேறுசில வேலைகளையும் இவை செய்கின்றன. எனவே இவற்றின் வெளியீட்டைக் கணிக்கமுடிவதில்லை.

தூய்மையான செயற்கூறுகள் பக்கவிளைவுகளற்றவை.

JavaScript, Java, C# போன்ற முக்கியமான நிரலாக்கமொழிகளில் பக்கவிளைவுகள் அதிகமாக இருக்கின்றன. ஒரு இனக்குழுவின் (class) செயற்கூறுகளனைத்தும், அதன் மாறிகளை மாற்றவல்லவை. இதனால், வழுக்களுக்கான காரணங்களை எளிதில் கண்டறிய முடிவதில்லை.

ஆனால், தூய்மையான செயற்கூறுகளை மட்டும் வைத்துக்கொண்டு ஒரு முழுமையான மென்பொருளை உருவாக்குவதெப்படி என நீங்கள் வியக்கலாம்.

செயல்பாட்டு நிரலாக்கத்தில் நாம் தூய்மையான செயற்கூறுகளை மட்டுமே எழுதுவதில்லை. எந்தவொரு மென்பொருள் நிரலிலும் தூய்மையற்ற பகுதிகள் இருந்தே ஆகவேண்டும். ஆனால், நாம் எழுதும் பெரும்பாலான செயற்கூறுகள் தூய்மையானவையாக இருக்கவேண்டும். செயல்பாட்டு நிரலாக்கமொழிகளால், பக்கவிளைவுகளை முழுமையாக அகற்றமுடியாது. ஆனால், ஒருகுறிப்பிட்ட வட்டத்திற்குள் கட்டுப்படுத்திவைக்கமுடியும்.

தூய்மையற்ற நிரலின் அளவைக்குறைத்து, நிரலின் பிறபகுதிகளிலிருந்து அதைப்பிரித்துவைப்பதே நமது நோக்கமாகும்.

பின்வரும் கட்டுரைகளில் செயல்பாட்டு நிரலாக்கத்தின் அடிப்படைகளை எளிய எடுத்துக்காட்டுகளுடன் அறிந்துகொள்ளலாம்.

மூலம்: Charles Scalfani எழுதிய கட்டுரைத்தொடரின் தமிழாக்கம். அவரது அனுமதியோடு மொழிபெயர்க்கப்பட்டுள்ளது.