"ஹலோ, அமிகோ! எங்களிடம் ஒரு புதிய மற்றும் மிகவும் கடினமான தலைப்பு உள்ளது. மன்னிக்கவும். இது ஜாவாவில் மட்டுமல்ல, பொதுவாக நிரலாக்கத்திலும் மிகவும் சிக்கலான தலைப்புகளில் ஒன்றாக கருதப்படுகிறது. நான் மல்டித்ரெடிங்கைப் பற்றி பேசுகிறேன் . "
ஒரு பொதுவான கணினி விளையாட்டை கற்பனை செய்து பாருங்கள், எடுத்துக்காட்டாக, ஒரு விண்கலம் பந்தய விளையாட்டு. விண்கற்கள் மற்றும் ரோந்து கப்பல்களை ஏமாற்றி, காஸ்மோஸின் விரிவாக்கங்கள் வழியாக நீங்கள் பறக்கிறீர்கள். இந்த சட்டவிரோத பந்தயங்களில் உங்களுடன் இன்னும் இரண்டு டஜன் பேர் பங்கேற்கின்றனர்.
நீங்கள் அத்தகைய விளையாட்டை எழுத முடிவு செய்கிறீர்கள் என்று வைத்துக்கொள்வோம். உங்கள் நிரல் கட்டளைகளை (விசைப்பலகை உள்ளீடு) கண்காணிக்க வேண்டும், விண்கலங்களை நகர்த்த வேண்டும், அவற்றின் பாதைகளைக் கணக்கிட வேண்டும், ஏதேனும் மோதல்களின் விளைவுகளைத் தீர்மானிக்க வேண்டும், மேலும் இவை அனைத்தையும் பயனரின் திரையில் வரைய வேண்டும். இது மிகவும் சிக்கலான வேலை.
வளர்ந்து வரும் கப்பல் நிறுவனத்தைப் பற்றிய எடுத்துக்காட்டில் "பெரிய சிக்கலான சிக்கலை" நாங்கள் எவ்வாறு தீர்த்தோம் என்பதை நினைவில் கொள்கிறீர்களா?
நாங்கள் அதை சுதந்திரமான துறைகளாகப் பிரித்து, அவர்கள் எவ்வாறு தொடர்பு கொள்ளலாம் என்பதை (தரப்படுத்தப்பட்ட) கடுமையாகக் குறிப்பிட்டோம்.
"ஆனால், சுதந்திரமான பாகங்கள் மற்ற பகுதிகளுக்கு இணையாக சில வேலைகளைச் செய்ய வேண்டியிருக்கும் போது நாம் என்ன செய்வது?! இந்தக் கேள்விக்கான பதில் நூல்கள்தான் . "
குறியீட்டைச் சுற்றி இயங்கும் மற்றும் கட்டளைகளை இயக்கும் ஒரு சிறிய ரோபோவாக ஒரு நிரலை கற்பனை செய்ய முயற்சிக்கவும் . முதலில், இது ஒரு வரியில் ஒரு கட்டளையை இயக்குகிறது, பின்னர் அடுத்த வரிக்கு நகரும், மற்றும் பல.
"எனக்கு மனசுல தெரிஞ்சுது. பீஸ் ஆஃப் கேக்!"
"மிக நல்லது. இப்போது உங்களிடம் இந்த ரோபோக்கள் பல இருப்பதாக கற்பனை செய்து பாருங்கள். ஒருவர் பயனர் உள்ளீட்டைக் கையாளும் போது, இரண்டாவது அந்த உள்ளீட்டின் அடிப்படையில் பொருட்களைப் புதுப்பிக்கிறது. மூன்றில் ஒருவன் இந்த பொருட்களை திரையில் காண்பிக்க குறியீட்டை இயக்குகிறது. ஒரு நொடிக்கு பலமுறை, நான்காவது கப்பல் ஏதேனும் மோதியதா என்பதைச் சரிபார்த்து, மோதியிருந்தால் அதன் முடிவுகளைக் கணக்கிடுகிறது."
எனவே, நாம் நிரலை சுயாதீனமான பகுதிகள்/பொருள்களாகப் பிரிப்பது மட்டுமல்லாமல், இந்த பகுதிகள் ஒருவருக்கொருவர் சுயாதீனமாக தங்கள் வேலையைச் செய்யும் வகையில் அதை உருவாக்கவும் முடியும். தனிப்பட்ட பகுதிகளுக்கு இடையே குறைவான தொடர்பு, குறைவான சிக்கலான நிரல்.
கடிதங்களை அனுப்பும் ஸ்கிரிப்ட் மூலம் நீங்கள் மேலாளரை மாற்ற முடியும் என்று கற்பனை செய்து பாருங்கள் . மற்ற நிறுவனத் துறைகளால் மாற்றம் ஏற்பட்டதாகக் கூட சொல்ல முடியவில்லை. 26 ஆம் நூற்றாண்டின் முற்பகுதியில் இது போன்ற நிகழ்வுகள் சிறந்த முடிவுகளுடன் நடந்தன. பெரும்பாலான மேலாளர்கள், மற்றும் உயர் நிர்வாகிகள் கூட, சராசரி சிக்கலான ஸ்கிரிப்ட் மூலம் வெற்றிகரமாக மாற்றப்படலாம். "அலுவலக பிளாங்க்டன் யூனியன்" தலையிட்ட பிறகுதான் மேலாளர்களின் வெகுஜன பணிநீக்கங்கள் முடிவுக்கு வந்தன. ஆனால் நான் விலகுகிறேன்.
"எவ்வளவு சுவராஸ்யமான!"
"இந்த "சிறிய ரோபோக்கள்" பல குறியீட்டை செயல்படுத்துவது மட்டுமல்லாமல், அவை ஒருவருக்கொருவர் தொடர்புகொண்டு புதிய ரோபோக்களை உருவாக்க முடியும்."
"புதிய ரோபோக்களை உருவாக்கவா?"
"ஆமாம், புதிய பணிகளைச் செய்ய. சில சமயங்களில் தற்போதைய இழை (ரோபோ) செய்யும் அதே நேரத்தில் சில செயல்களைச் செய்ய மற்றொரு ரோபோவை (மற்றொரு நூல்) உருவாக்குவது சாதகமாக இருக்கும்."
" இது ஒரு நல்ல விஷயம் போல் தெரிகிறது, ஆனால் நான் இதை எங்கு பயன்படுத்துவேன் என்று என்னால் நினைக்க முடியவில்லை. "
நாம் ஏன் அவற்றை " இழைகள் " என்று அழைக்கிறோம்?
"ஒவ்வொரு ரோபோவும் வெவ்வேறு நிறத்தில் இருப்பதாக கற்பனை செய்து, கட்டளைகளை அதன் வண்ணத்தால் குறிக்கும். சிறிய ரோபோ செல்லும் பாதை ஒரு பென்சில் விட்டுச் சென்ற கோடு போன்றது. இந்த பாதை ரோபோவின் பின்னால், பின்னால் ஒரு நூல் போல் செல்கிறது . ஒரு ஊசி."
ஒவ்வொரு "சிறிய ரோபோ" க்கும் ஒரு பணி உள்ளது, அது செய்ய உருவாக்கப்பட்டது. இந்த பணியைச் செய்யும்போது செயல்படுத்தப்படும் கட்டளைகளின் தொகுப்பே நூல் என்று நீங்கள் நினைக்கலாம்.
நீங்கள் சரக்குகளை வழங்குவதற்காக ஒரு விண்கலத்தில் பறக்கிறீர்கள் என்று வைத்துக்கொள்வோம். பின்னர் "சரக்குகளை வழங்குதல்" என்பது உங்கள் பணியாகும், மேலும் நீங்கள் அதைச் செய்வதற்கு நடுவில் உள்ளீர்கள். உங்கள் விமானப் பாதை உங்கள் நூல். ஒவ்வொரு புதிய பணியும், இன்னும் முடிக்கப்படாத ஒவ்வொரு பணிக்கும் அதன் சொந்த நூல் உள்ளது என்று நாம் கூறலாம் (இன்னும் பயணிக்க வேண்டிய பாதை).
"வேறு வார்த்தைகளில் கூறுவதானால், ஒரு பணி மற்றும் அதைச் செயல்படுத்தும் ஒரு "சிறிய ரோபோ" உள்ளது. மேலும் ஒரு நூல் என்பது ரோபோ தனது பணியை முடிக்கும்போது செல்லும் பாதையா?"
"சரியாக."
இப்படித்தான் அனைத்தும் உள்ளே ஆழமாகச் செயல்படுகின்றன. கணினியில் ஒரே ஒரு செயலி இருப்பதால், ஒரு நேரத்தில் ஒரு கட்டளையை மட்டுமே இயக்க முடியும். எனவே என்ன நடக்கிறது என்பது இங்கே: செயலி தொடர்ந்து நூல்களுக்கு இடையில் மாறுகிறது. இது ஒரு புதிய நூலுக்கு மாறுகிறது, சில கட்டளைகளை இயக்குகிறது, பின்னர் அடுத்த தொடரிழைக்கு மாறுகிறது, சில கட்டளைகளை இயக்குகிறது மற்றும் பல. ஆனால் நூல்களுக்கு இடையில் மாறுவது ஒரு நொடிக்கு நூற்றுக்கணக்கான முறை நிகழும் என்பதால், எல்லா இழைகளும் ஒரே நேரத்தில் இயங்குவதாக நமக்குத் தோன்றுகிறது.
