ஜாவா ஃபார் டம்மீஸ் - எந்தவகையில் சிறந்தது ஜாவா

ஒரு வகையாக ப்ரொக்கிராம்(மிங்) என்றால் என்ன? எதற்காக எழுதுகிறார்கள் என்பதை பார்த்துவிட்டோம். இப்பொழுது எந்த வகையில் ப்ரொக்கிராமிங் செய்ய ஜாவா சிறந்தது என்று பார்ப்போம். தற்சமயங்களில் எல்லாம் என்னுடைய மனநிலை, ஜாவா பெரிதா VB பெரிதா என்பது போன்ற சண்டையில் விருப்பம் இல்லாமல். க்ளயண்டுக்கு நாம் எழுதிக் கொடுக்கும் ப்ரொடக்ட், இல்லை ப்ரொஜக்ட் எந்த அளவிற்கு உபயோகமாகயிருக்கிறது என்பதைப் பற்றி யோசிக்க ஆரம்பித்து விட்டேன். இதற்கு நான் தற்சமயம் வேலை செய்து வரும் ப்ரொடக்ட் ஒரு காரணம் அதைப் பற்றி கடைசியில் எழுதுகிறேன்.

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

பலர் ஜாவாவை ப்ரொக்கிராமிங் லாங்க்வேஜாக ஒப்புக்கொள்ள மாட்டார்கள். ஆனால் ஜாவாவை ஆப்பரேட்டிங் ஸிஸ்டமாகவும்(விண்டோஸ், லினக்ஸ் போல்) ஒப்புக்கொள்ள முடியாது. ஜாவாவை ஏன் ஆப்பரேட்டிங் ஸிஸ்டமாக பார்க்க வேண்டி வருகிறதென்றால். ஜாவா ப்ரொக்கிராம்கள் எல்லாமே Java Virtual Machine என்ற ஒன்றால் தான் செயல்படுத்தப் படுகிறது. இந்த JVM(Java Virtual Machine) உங்கள் ஆப்பரேட்டிங் சிஸ்டம் சம்மந்தப் படாதது, இன்னும் சரியாகச் சொல்லவேண்டுமென்றால் ஆப்பரேட்டிஸ் சிஸ்டத்தோடு சம்மந்தப்படாமல் தனியாக இயங்கக் கூடியது.

நீங்கள் ஜாவாவை அதனுடைய வெப்சைட்டான java.sun.com ல் தேடினால் எல்லா இடங்களிலும் Java Platform, Standard Edition என்று குறிப்பிடுவதைப் பார்க்கலாம்(இதைப்போலவே Java Platform - Enterprise Edition, Java Platform - Micro Edition). நான் ஆரம்பக் காலங்களில் இன்டர்வியூ அட்டெனட் செய்யும் பொழுது இது நிச்சயமான ஒரு இன்டர்வியூ கொஸ்டீன். ஆனால் ப்ரஷ்ஷர்களுக்காக மட்டுமே. இதில் இந்த ப்ளாட்ஃபார்ம் எனப்படும் விஷயம் தான் நான் சொன்ன JVM பற்றியது. இதன் காரணமாகவே ஜாவாவை சாப்ட்வேர் ஆப்பரேட்டிங் ஸிஸ்டம் என்றும் சொல்வதுண்டு.

இப்பொழுது Java Operating System என்றொரு ஆப்பரேட்டிங் ஸிஸ்டம் கொண்டுவருவதற்கான முயற்சிகள் நடைபெற்றுவருகின்றன.(முடிந்துவிட்டன - செயலிலும் உள்ளது) அது சாஃப்ட்வெர், ஹார்ட்வேர் இரண்டிற்குமான சப்போர்ட்டை உள்ளடக்கியது.

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



JIT என்பது Just In-time Compiler, இதைப் பற்றி பார்ப்பதற்கு முன் இதன் பின்னால் இருக்கும் வரலாற்றைப் பார்த்துவிடலாம். ஜாவாவின் முக்கியத்துவமாக எல்லோரும் சொல்வது ஜாவாவை எந்த ஆப்பரேட்டிங் ஸிஸ்டத்திலும் எந்த ப்ராசசரிலும் உபயோகிக்கலாம் என்பது. இன்னும் சரியாகச் சொல்லவேண்டுமென்றால் நீங்கள் மைக்ரோசாஃப்ட் விண்டோஸில் உட்கார்ந்து எழுதிய ஜாவா ப்ரொக்கிராமை(ப்ரொக்கிராம் என்று சொல்லும் இடத்தில் எல்லாம் அதை கலெக்ஷன் ஆ வைத்து ப்ரொஜெக்ட்டாவும் பார்க்கலாம்) எந்த வித மாற்றமும் இல்லாமல் நாளை லினக்ஸில் உபயோகிக்கலாம்.

சரி இன்னும் கொஞ்சம் விரிவாக, நீங்கள் C, C++ இலோ ஒரு ப்ரொக்கிராம் எழுதுகிறீர்கள் என்று வைத்துக் கொள்ளுங்கள். அதை கம்பைல் செய்வது என்று ஒரு விஷயம் உண்டு. அதாவது மனிதன் புரிந்து கொண்டு எழுதும் ஒரு விஷயத்தை மெஷின் புரிந்து கொள்ளும் விஷயமாக மாற்றுவது. உங்களுக்கு கம்ப்யூட்டரில் எல்லா விஷயங்களுமே 0 மற்றும் 1 ஆக மாறி மட்டுமே பாதுகாக்கப் படவோ இல்லை செயல்படுத்தப்படவோ செய்யும். சின்ன உதாரணம் நீங்கள் கம்ப்யூட்டர் கால்குலேட்டரில் 2 + 3 என்று சொன்னால் அது, உண்மையில் இரண்டிற்கான 0001 யையும் மூன்றிற்கான 0010 வையும் எடுத்துக் கொண்டு போய், மைக்ரோ ப்ராஸஸரில் போட்டு கூட்டி 0101 என்ற விடையை எடுத்துக் கொண்டு வந்து பின்னர் அந்த 0101 வை மனிதன் புரிந்து கொள்ளும் விதமாக 5 என்றும் காட்டும்.

இப்படி மனிதன் புரிந்துகொள்ளும் விஷயத்தை மைக்ரோப்ராஸஸர் புரிந்து கொள்ளும் ஒன்றாகவும், மைக்ரோ ப்ராஸஸர் புரிந்து கொள்ளும் ஒரு விஷயத்தை மனிதன் புரிந்து கொள்ளும் ஒரு விஷயமாகவும் மாற்றுவதே கம்பைல் மற்றும் டிகம்பைல் என்று சொல்லலாம்.

இப்படித்தான் எழுதப்பட்ட C, C++ ப்ரொக்கிராம் கோடுகளையும் மைக்ரோ ப்ராஸஸர் புரிந்து கொள்ளும் ஒரு விஷயமாக மாற்றும் பொழுது ஒரு பிரச்சனை ஏற்படும். எப்படி என்றால் மேற்சொன்ன கூட்டல் விஷயத்தை நடத்த Intel Pentium microprocessor உபயோகிக்கும் முறைகளும் IBM System/390 processor உபயோகிக்கும் முறைகளும் வேறுபடும். எனவே நீங்கள் ஒரு கம்ப்யூட்டரில் Pentium Processor உபயோகிக்கிறீர்கள் என்றால் அதற்கான கூட்டல் முறையாகத்தான் உங்கள் கம்பைலர் மாற்றிக் கொடுக்கும். இப்படித்தான் ஜாவாவிற்கு முன்னால் இருந்த கம்பைலர்கள் இருந்தன.

இதன் காரணமாக நீங்கள் Pentium Processor க்கு எழுதப்பட்ட ஒரு ப்ரொக்கிராமை(உதாரணத்திற்கு நம் கூட்டல்) IBM Processor ல் உபயோகப்படுத்த முடியாது. இதையெல்லாம் சரிசெய்தது ஜாவா. சரி சரிசெய்ததென்றால் எப்படிச் செய்தது. இங்கே தான் வருகிறது ஜாவாவின் கம்பைலர். சரி விஷயத்திற்கு வருகிறேன். இந்த ஜாவா கம்பைலர் கம்பைலர் தான் அந்த மேஜிக்கை செய்கிறது, அதாவது ஜாவாவில் நேரடியாக ஜாவா ப்ரொக்கிராமை மைக்ரோ ப்ராஸஸர் புரிந்து கொள்ளும் விதமாக மாற்றாமல் இடைப்பட்ட ஒன்றாக மாற்றிக்கொள்ளும் (டெக்னிக்கலாக Byte code). அந்த இடைப்பட்ட ஒன்றைத்தான் உண்மையான ப்ராஸஸருக்கு ஏற்றதுபோல் மாற்றிக்கொடுக்கும். இதனால் நீங்கள் எந்த ஆப்பரேட்டிங் ஸிஸ்டத்தில் உட்கார்ந்து எந்த ப்ராஸஸருக்கு ப்ரொக்கிராம் எழுதினாலும் அதை மற்ற ப்ராஸஸருக்கு உபயோகிக்க முடியும். ஏனென்றால் நீங்கள் எழுதிய ப்ரொக்கிராமின் இடைப்பட்ட மாற்றத்தை(Byte Code)ஐ அந்தந்த ப்ராஸஸருக்கு ஏற்றது போல் மாற்றிக் கொடுக்கும் JVM.


ரொம்பவும் டெக்னிக்கலாகப் போய்விட்டது என்று நினைக்கிறேன். இதுதான் ஜாவாவின் மேஜிக் எனப்படும் ஒன்று. புரியாவிட்டால் கேளுங்கள் என்னால் முடிந்த வரை விளக்கப் பார்க்கிறேன். ரொம்ப டெக்னிக்கலாக இருப்பதால் இது போதும்.

PS: இதில் கான்செப்ட் வைஸ் எதுவும் தவறிருந்தால் சொல்லவும் திருத்திவிடுகிறேன்.

முன்பு எழுதியவை

(ஜாவா) ப்ரொக்கிராமிங் ஃபார் டம்மீஸ்
என் ஜாவா அனுபவங்கள்
என் முதல் இன்டர்வியூ அனுபவம்(ங்கள்)