Labu Kate - ලබුකැටය

                                                                 Translators





මම කලින් post එකේදී ඔයාලට කිව්වා High level language එකකින් ලියපු program එකක් එය මුලින්ම ක්‍රියා කරවීමේදී එය Translators එකක් හරහා  Machine code එකකට හැරෙනවා කියල . මුලිකවම  Translators වර්ග 2ක් තියෙනවා .

01. Compiler
02. Interpreter

Compiler

භාෂා පරිවර්තකයෝ වර්ග දෙකක් ඉන්නවා. එක වර්ගයකට කලින් කතාව ලියලා දුන්නහම ඒ ගොල්ලෝ කතාවෙ වැරදි එහෙම තියෙනවනම් ඒවා හදලා මුලු කතාවම වෙනත් භාෂාවකට හරවනවා. කතාව කරන කෙනාට තියෙන්නෙ පරිවර්තනය කරපු කතාව කියවන එකයි.
Compiler කියන වර්ගයේදී ඉස්සෙල්ලාම නියෝග මාලාව හෙවත් program එක ලියනවා. ඒකට අපි source code එක කියලා කියනවා.
මෙහිදී program එක මුලින්ම ක්‍රියා කරවීමේදී Compiler එකක් හරහා  සම්පූර්ණ program එකම Machine code එකට හැරෙවනවා
එහිදී program එකේ ඇති සියලුම වැරදි ලැයිස්තුව අප ඉදිරිය් පෙන්වනවා. ඒ වැරදි නිවැරදි කරලා ආයමත් compile කලහම Compile වූ program එක ලැබෙනවා. දැන් අර මුල් source code එක නැතිව වුවත් අපිට program එක ක්‍රියාත්මක කරලා අවශ්‍ය දේ ලබාගන්න පුලුවන්.
ඒත් යම් විදියකින් අපට අපි ලිව්ව program එකේ යම් නියෝගයක් වෙනස් කිරීමට අවශ්‍ය නම් ඒක compile කල program එක පාවිච්චි කරලා කරන්න බැහැ. ආයමත් අපට source code එක ගන්න වෙනවා. source code එකේ අවශ්‍ය වනස්කම් කරලා ආයත් compile කරලයි වෙනස් කරන ලද program එක පාවිච්චි කරන්න පුලුවන් වෙන්නෙ.

උදාහරණ - C,C++

Interpreters

හිතන්න භාෂා පරිවර්තනය කිරීම්දී බැරි වෙලාවත් කතාව කරන කෙනා කොලයක් බලන්න් නැතිව එවෙල් හිතලා කතා කරනවා කියල. එවැනි වලාවක පරිවර්තකයාට මුළු කථාවම පරිවර්තනය කිරීමක් ගැන හිතන්නවත් බැහැ.මොකද එහම මුළු කතාවම එවෙලම පරිවර්තනය කරන්න බැහැ. එතකොට කරන්න තියන්න් කථිකයා කතාකරන පේලියන් පේලිය පරිවර්තකයා විසින් අවශ්‍ය අනෙක් භාෂාවට පරිවර්තනය කිරීමයි. මේ වැඩේදී වැරදී අහුවෙන්න් ඒ ඒ පපේලිය කතා කරනකොටයි. ඒ කියන්න් ඒ පේලියට ආවහමයි.
මේ වගේමයි Interpreters එකක් පවිච්චි කරල High level language එකකින් ලිව්ව program එකක් Machine code එකට හැරවීමේදී වෙන්නෙත්
ඇත්තටම compiler එකේ  වගේ විශේෂයන් එහෙම Translate කිරීමක් කරන්න අපිට සිද්ද වෙන්න් නැහැ. අපි High level language එකකින් program එක ලියලා ඒක කියාත්මක කරනවිට පේලියන් පේලියයි Interpreter එක මගින් Machine code එකට හරවන්නේ.
ඊලඟට ඒ හැරවුනු පේලිය ක්‍රියාවට කියාවට නැගනවා. මෙතනදී යම් පේලියක වරදක් තියනවනම් ඒ පේලියට ආවහම තමයි ඒ වැරැද්ද පේන්නෙ. ඒ වැරැද්ද නිවැරදි කරලා ආයත් program එක කියාත්මක කළහම ඊළඟ ප්ලිය් තවත් වැරැද්දක් තියනවනම් ඒ වැරැද්ද පෙන්වනවා.
ඒ විදිහට වැරද්දක් නැත්නම් පේලියෙන් පේලිය සම්පුර්ණ program එකම ක්‍රියාවට නැගෙනවා.

උදාහරණ - Python

දැන් ඔබට තේරෙනවා  ඇති Compiler එකකින් Translate කරද්දි ඒ වැඩේ කරන්න ඕන එක පාරක් විතරක් හන්දා කලායින් පස්සේ අපට ඕනෙ වාර ගණනක් Compile කල program එක කියාත්මක කරන්න පුලුවන්කියලා. ඒ නිසා මේ ක්‍රමය  වඩා වේගවත් වෙනවා.
ඒත් Interpreter එකකින් කරද්දී අපි program එක කියාත්මක කරන වාරයක් වාරයක් ගානේ Interpreter වෙන නිසා මේ  විදිය ටිකක් වෙලා යනවා.
අද කාලෙ භාවිතා වෙන වඩා දියුනු නවීන low level languages වල
(Visual Basic, Java) මේ  ලක්ෂණ දෙකම තියෙනවා.

මම හිතනවා පොදුවේ programming කියන්නේ මොකක්ක්ද කියල අදහසක් මේ post 2න් ඔයාලට ලැබෙන්න ඇති කියල. ඉදිරියේදී C,C++,Python,Java කියන මේ භාෂා ගැන වෙන වෙනම කතා කරන්න අපි බලාපොරොත්තු වෙනවා.

Thank you...