«Ինտերպրետատոր»–ի խմբագրումների տարբերություն

Առանց խմբագրման ամփոփման
(Չի նշված պատասխանատու մասնակիցը)
No edit summary
{{խմբագրում եմ}}
Ինտերպրետատորը ծրագիր է, որը ուղղակիորեն [[Ծրագրի կատարում|կատարում]] է,[[Ծրագրավորման լեզու|ծրագրավորման]] կամ սկրիպտավորման լեզուներով գրված համաններ,առանց դրանք նախապես [[Կոմպիլայացիա|կոմպիլյացնոլով]] մեքենայական լեզվի ծրագրի։ ինտերպրետատորը ծրագրի կատարման համար  հիմանակնաում օգտագործում է հետևյալ ստրատեգիաներից մեկը՝
{{Ծրագրի իրականացում}}
<nowiki># վերլուծել </nowiki>[[Ելակետային կոդ|սկզբանկան կոդը]]  և ուղղակիորեն կատարել:<div>#թարգմանել <nowiki/>[[Ելակետային կոդ|սկզբանկան կոդը]],ինչ որ միջանկյալ տեսքի և իրականցնել այն:<br>
Ինտերպրետատորը ծրագիր է, որը ուղղակիորեն [[Ծրագրի կատարում|կատարում]] է,[[Ծրագրավորման լեզու|ծրագրավորման]] կամ սկրիպտավորման լեզուներով գրված համաններհրամաններ,առանց դրանք նախապես [[Կոմպիլայացիա|կոմպիլյացնոլով]] մեքենայական լեզվի ծրագրի։ ինտերպրետատորը ծրագրի կատարման համար  հիմանակնաում օգտագործում է հետևյալ ստրատեգիաներից մեկը՝
</div><div>#Հստակ իրականցնել պահպանված նախակոմպիլյացված(<nowiki>{{lang-en| precompiled}}</nowiki>) կոդը՝ կոմպիլյատորի կողմից կազմված,որը հանդիսանում է ինտերպրետատորի համակարգի մի մաս:<br>
1. վերլուծել({{lang-en|parse}}) [[Ելակետային կոդ|սկզբանկան կոդը]]  և ուղղակիորեն կատարել:
</div>
<nowiki>#2. վերլուծել </nowiki>[[Ելակետային կոդ|սկզբանկան կոդը]]  և ուղղակիորեն կատարել:<div>#թարգմանել <nowiki/>[[Ելակետային կոդ|սկզբանկան կոդը]], ինչ որ միջանկյալ տեսքի և իրականցնել այն:<br>
Սկզբնական ծրագրերը կոմպիլյացվում են նախապես և մեքենայում պահվում որպես անկախ կոդ, որը հետո [[Կապերի խմբագրիչ|կապվում]] է կատարման ժամանակ և իրականացվում ինտերպրետատորի և/կամ կոմպիլյատորի կողմից(<nowiki>{{</nowiki>lang-en| [[Just-in-time compilation|JIT]] <nowiki>}}</nowiki>կոմպիլյացիայի համակարգի համար):
</div><div># 3. Հստակ իրականցնել պահպանված նախակոմպիլյացված(<nowiki>{{lang-en| precompiled}}</nowiki>) կոդը՝ կոմպիլյատորի կողմից կազմված,որը հանդիսանում է ինտերպրետատորի համակարգի մի մաս:<br>
 
Սկզբնական ծրագրերը կոմպիլյացվում են նախապես և մեքենայում պահվում որպես անկախ կոդ, որը հետո [[Կապերի խմբագրիչ|կապվում]] է կատարման ժամանակ և իրականացվում ինտերպրետատորի և/կամ կոմպիլյատորի կողմից(<nowiki>{{</nowiki>lang-en| [[Just-in-time compilation|JIT]] <nowiki>}}</nowiki> կոմպիլյացիայի համակարգի համար):
Չնայած ինտերպրետացիան և կոմպիլյացիան համարվում են երկու հիմանական միջոց ծրագրավորման լեզուների իրականցման համար,դրանք չեն հակասում միմյանց,որովհետև ինտերպրետացվող համկարգերի մեծ մասը կատարում է նաև թարգմանչական աշխատանք,ինչպես կոմպիլյատորը: "Ինտերպրետացվող լեզու" կամ "կոմպիլյացվող լեզու" տերմինները նշանակում են որ տվյալ լեզվի իրականցումը տեղի է ունենում ինտերպրետատորի կամ կոմպիլյատորի միջոցով՝ համապատասխանաբար:
 
Չնայած ինտերպրետացիան և կոմպիլյացիան համարվում են երկու հիմանական միջոց ծրագրավորման լեզուների իրականցման համար,դրանք չեն հակասում միմյանց,որովհետև ինտերպրետացվող համկարգերի մեծ մասը կատարում է նաև թարգմանչական աշխատանք, ինչպես կոմպիլյատորը: "Ինտերպրետացվող լեզու" կամ "կոմպիլյացվող լեզու" տերմինները նշանակում են որ տվյալ լեզվի իրականցումը տեղի է ունենում ինտերպրետատորի կամ կոմպիլյատորի միջոցով՝ համապատասխանաբար:
 
== Կոմպիլյատորների և ինտերպրետատորների համեմատումը ==
Բարձր մակարդակի լեզուներով գրված ծրագրերը,  կամ ուղղակիորեն իրականցվում են ինտերպրետատորի ինչ-որ մի տեսակով, կամ կոմպիլյատորի կողմից ձևափոխվում են [[Machine code|մեքենայական կոդի]]՝ պրոցեսորի համար,որպեսի այն կատարի: 
 
Չնայած կոմպիլյատորների հիմանկան արդյունքը հարդվերի կողմից գործարկվող մեքենայական կոդն է,դրանց արդյունքը հաճախ կարող է ընդունել միջանկյալ տեսք՝ [[Object code|օբյեկտային կոդ]](<nowiki>{{lang-en| object code }}</nowiki>) անվանմամբ: Կոմպիլյացվող ծրագիրը սովորաբար օգտագործում է կառուցվող բլոկներ (ֆունկցիաներ) գրադարանում պահված այդպիսի օբյեկտային կոդի մոդուլներ. [[LinkerԿապերի (computing)|Լինկերնխմբագրիչ]]ը (<nowiki>{{lang-en| linker }}</nowiki>)օգտագործում է գրադարանային ֆայլերը օբյեկտային ֆայլերի հետ միավորելու համար  մեկ գործարկվող (<nowiki>{{lang-en| executable }}</nowiki>) ֆայլում:
 
Երկուսն էլ՝ կոմպիլյատորները և ինտերպրետատորները հիմնականում սկզբնական կոդը վերածում են թոկեններիթոքենների (<nowiki>{{lang-en| token}}</nowiki>), երկուսն էլ կարող են գեներացնել վերլուծության ծառ(<nowiki>{{lang-en| parse tree}}</nowiki>),և երկուսն էլ կարող են գեներացնել անմիջական հրահանգներ (ստեկային մեքենայի համար,կամ այլ  միջոցներով): Հիմնական տարբերությունը այն է, որ կոմպիլյացվող համկարգերը,այդ թվում լինկերը, գեներացնում են ակախ գործող մեքենայական կոդի  ծրագիր, մինչ դեռ ինտերպրետացվող համակարգերը դրա փոխարեն իրականցնում են գործողություններ նկարագրված բարձր մակարդակի լեզուներով:
 
 
[[File:kaantotulkkaus.png|thumb|upright=1.87 | Կոմպիլյացում և ինտերպրետացում ]]
 
 
Երկուսն էլ՝ կոմպիլյատորները և ինտերպրետատորները հիմնականում սկզբնական կոդը վերածում են թոկենների (<nowiki>{{lang-en| token}}</nowiki>), երկուսն էլ կարող են գեներացնել վերլուծության ծառ(<nowiki>{{lang-en| parse tree}}</nowiki>),և երկուսն էլ կարող են գեներացնել անմիջական հրահանգներ (ստեկային մեքենայի համար,կամ այլ  միջոցներով): Հիմնական տարբերությունը այն է, որ կոմպիլյացվող համկարգերը,այդ թվում լինկերը, գեներացնում են ակախ գործող մեքենայական կոդի  ծրագիր,մինչ դեռ ինտերպրետացվող համակարգերը դրա փոխարեն իրականցնում են գործողություններ նկարագրված բարձր մակարդակի լեզուներով:
 
Կոմպիլյատորը փոխակերպում  է միանգամից ամբողջ սկզբնական կոդը:Արդյունքը ստացվում է մեկ կամ մի քանի օբյեկտային կոդի ֆայլեր: Իտերպրետատորը նույնպես փոխակերպում է սկզբանական կոդը,սակայն տող առ տող:Երբ առաջին տողը արդեն փոխակերպված է,այն միանգամից  կատարվում է:
 
Կոմպիլյաորը չի թույլատրում գործարկել ծրագիրը,քանի դեռ այն լիովին անսխալ է: Ինտերպրետատորը [[Ծրագրի կատարում|կատարում]]  է ծրագիրը առաջին տողից սկսած և դադարում է միայն այն դեպքում, երբ հանդիպում է սխալ: 
 
 
 
=== Մշակման ցիկլ ===
Ծրագրային ապահովման մշակման ցիկլում, ծրագրավորողները սկզբնկան կոդում հաճախակի փոփոխություններ են կատարում։ Կոմպիլյատորի օգտագործման դեպքում, ամեն անգամ երբ սկզբնական կոդը փոխվում է , դրանք պետք է սպասեն կոմպիլյատորին,որպիսի թարգմանի փոխված սկզբնական ֆայելրը (<nowiki>{{lang-en| source file}}</nowiki>), և [[Կապերի խմբագրիչ|կապի]] բոլոր երկուական կոդերի ֆայլերը իրար, հետո ծրագրը կարող է կատարվել։ Ինչքան ծրագիրը մեծ է,այդքան երկար պետք է սպասել։ Ինտերպրետատորի օգտագործման դեպքում ծրագրավորողը սպասում է ավելի քիչ,քանի որ ինտերպրետատորը կոդը թարգմանում է ներկայացնելով այն միջանկյալ տեսքով(կամ ամբողջը չի թարգմանում)։ Հետևությունները դառնում է ակնհայտ,սկզբանակն կոդը պահելուց (<nowiki>{{lang-en| saving}}</nowiki>) և ծրագիրը բեռնելուց(<nowiki>{{lang-en| reloading}}</nowiki>) հետո։
 
=== Բաշխման սկզբունք ===
Կոմպիլյատորը սկզբնական կոդը փոխակերպում է բինար ինստրուկցիաների, հատուկ պրոցեսսորի համար, դարձնելով այն ավելի քիչ դյուրակիր(<nowiki>{{lang-en| portable}}</nowiki>)։ Այդ փոխակերպումը տեղի է ունենում միայն մեկ անգամ և դրանից հետո նույն բինար ինստրուկցիաները տեղաբաշխում են օգտագործողի մեքենայում, որտեղ այն կարողանում է կատարվել առանց հետգա թարգմանությունների։ [[Խաչաձև կազմարկիչ|Կրոսս կոմպիլյատորներ]]<nowiki/>ը կարողանում են գեներացնել բինար կոդ օգտագործողի մեքենայի համար, անգամ եթե այն ունի այլ պրոցոսսոր քան մեքենան, որտեղ կոդը կոմպիլյացվում է։
 
Ինտերպրետացվող ծրագրերը կարող են բաշխվել սկզբնական կոդի տեսքով։ Այն պետք է թարգմանված լինի յուրաքանչյուր վերջնական մեքենայում, որը շատ ժամանկակ է տևում, բայց ծրագիրը տեղաբաշխում է անկախ մեքենայի ճարտարապետությունից։  Այնուամենայնիվ, ինտերպրետացվող սկզբանկան կոդերի տեղափոխումը  կախված է նշվածելքային մեքենայից (<nowiki>{{lang-en| target machine}}</nowiki>) իրապես ունենալով  համապատասխան ինտերպրտատոր։
 
Ինտերպրետացվող ծրագրերը կարող են բաշխվել սկզբնական կոդի տեսքով։ Այն պետք է թարգմանված լինի յուրաքանչյուր վերջնական մեքենայում, որը շատ ժամանկակ է տևում, բայց ծրագիրը տեղաբաշխում է անկախ մեքենայի ճարտարապետությունից։  Այնուամենայնիվ, ինտերպրետացվող սկզբանկան կոդերի տեղափոխումը  կախված է նշված մեքենայից (<nowiki>{{lang-en| target machine}}</nowiki>) իրապես ունենալով  համապատասխան ինտերպրտատոր։
 
=== Էֆեկտիվություն ===
Հիմանականում ինտերպրետատորի թերությունը հանդիսանում է այն, որ ինտերպրետատորը ծրագիրը կատարում է  դանդաղ, քան եթե այն կոմպիլյացված լիներ։ Արագության փոփոխությունը կարող է լինել մեծ կամ  փոքր։Ինտերպրետատորի ներքևի ծրագրը աշխատացնելու համար, այն հիմանկանում զբաղեցնում է երկար ժամանակ, քան կոմպիլյացված ծրագրն աշխատացնելը, բայց  դա ինտերպրետացնելու համար այն կարող է զբաղեցնել քիչ ժամանակ, քան դա կոմպյացնելու և աշխատացնելու ընդհանուր ժամանակը ։  Սա հատկապես կարևոր է, երբ նախատիպավորվում և տեստավորվում է կոդը, երբ խմբագիր-ինտերպրետատոր-դեբագ ցիկլը(<nowiki>{{lang-en|edit-interpret-debug }}</nowiki>) հաճախ կարող է լինել շատ ավելի կարճ քան խմբագիր-կոմպիլյացիա-կատարում-դեբագ (<nowiki>{{lang-en| edit-compile-run-debug }}</nowiki>) ցիկլը։
 
 Կոդի ինտերպրետացումը կատարվում է ավելի դանդաղ է, քան կոմպիլյացվող կոդի կատարումը, քանի որ ծրագրում  ինտերպրետատորը պետք է  վերլուծի յուրաքանչյուր  հրաման, ամեն անգամ երբ այն կատարվում է և հետո կարի անհրաժեշտ գործողություններ, մինչդեռ կոմիլյացվող կոդը ուղղակի կատարում է գործողություններ, ֆիքսված կոնտեքստում՝ կոմպիլյատորի կողմից սահմանված։ Դա [[Ծրագրի կատարման ժամանակ|կատարման ժամանակ]]<nowiki/>ի վերուծությունն է։ Ինտերպրետատորում փոփոխականների հասանելությունը ևս դանդաղ է, քանի որ պահպանման տեղերում իդենտիֆիկատորների մափփինգը(<nowiki>{{lang-en| mapping}}</nowiki>) պետք է անել հաճախակի կատարման ժամանակ, այլ ոչ թե [[կոմպիլյացիայի ժամանակ]]։
 
Մշակման արագության(երբ օգտագործում են ինտերպրետատոր) և կատարման արագության (երբ օգտագործում են կոմպիլյատորներ)  միջև գոյություն ունեն տարբեր կոմպրոմիսներ։ Որոշ համակարգեր (օրինակ որոշ լիսպեր)թույլատրում են ինտերպրետացնել և կոմպիլյացնել կոդը կանչելով միմյանց և բաժանելով փոփոխականները։ Շատ Ինտերպրետատորներ սկզբնական կոդը չեն կատարում, ինչպես արժե, բայց այն փախակերպում են ինչ-որ ավելի կոմպակտ ներքին տեսքի։ Շատ հիմանական ինտերպրտատորներ բանալի բառերը փոխարինում են մի [[բայթ]] նիշերի (<nowiki>{{lang-en| byte tokens }}</nowiki>) , որոնք կարող են  օգտագործվել անցման աղյուսակներում (<nowiki>{{lang-en| jump table}}</nowiki>) ինստրուկցիաների որոնման համար։ Որոշ ինտերպրետատորներ, ձգտում են ավելի բարձր մակարդակի ծրագրերի խտացման`   օգտագործելով <nowiki/>[[բիթ]]-կողմնորոշված(այլ ոչ թե բայթ-կողմնորոշված ) ծրագրերի հիշողության ստրուկրուրաներ, որտեղ նշանների հրամանները հնարավոր է զբաղեցնեն 5 բիթ, անվանապես "16-bit" հաստատնները պահվում են փոփոխական-երկարության կոդում (<nowiki>{{lang-en| variable-length code }}</nowiki>, այն կոդ է, որը ցուցադրում է սկզբնական սիմվոլները  փոփոխականի թվերի բիթերով ) պահանջելով 3, 6, 10, կամ 18 բիթ և օպերանդի հասցեն ներառում է <բիթ օֆսեթ> (<nowiki>{{lang-en| bit offset}}</nowiki>
 
 Կոդի ինտերպրետացումը կատարվում է ավելի դանդաղ է, քան կոմպիլյացվող կոդի կատարումը, քանի որ ծրագրում  ինտերպրետատորը պետք է  վերլուծի յուրաքանչյուր  հրաման, ամեն անգամ երբ այն կատարվում է և հետո կարի անհրաժեշտ գործողություններ, մինչդեռ կոմիլյացվող կոդը ուղղակի կատարում է գործողություններ, ֆիքսված կոնտեքստում՝ կոմպիլյատորի կողմից սահմանված։ Դա [[Ծրագրի կատարման ժամանակ|կատարման ժամանակ]]<nowiki/>ի վերուծությունն է։ Ինտերպրետատորում փոփոխականների հասանելությունը ևս դանդաղ է, քանի որ պահպանման տեղերում իդենտիֆիկատորների մափփինգը(<nowiki>{{lang-en| mapping}}</nowiki>) պետք է անել հաճախակի կատարման ժամանակ, այլ ոչ թե [[կոմպիլյացիայի ժամանակ]]։
 
{| align="right" class="wikitable collapsible collapsed" style="text-align:left"
Մշակման արագության(երբ օգտագործում են ինտերպրետատոր) և կատարման արագության (երբ օգտագործում են կոմպիլյատորներ)  միջև գոյություն ունեն տարբեր կոմպրոմիսներ։ Որոշ համակարգեր (օրինակ որոշ լիսպեր)թույլատրում են ինտերպրետացնել և կոմպիլյացնել կոդը կանչելով միմյանց և բաժանելով փոփոխականները։ Շատ Ինտերպրետատորներ սկզբնական կոդը չեն կատարում, ինչպես արժե, բայց այն փախակերպում են ինչ-որ ավելի կոմպակտ ներքին տեսքի։ Շատ հիմանական ինտերպրտատորներ բանալի բառերը փոխարինում են մի [[բայթ]] նիշերի (<nowiki>{{lang-en| byte tokens }}</nowiki>) , որոնք կարող են  օգտագործվել անցման աղյուսակներում (<nowiki>{{lang-en| jump table}}</nowiki>) ինստրուկցիաների որոնման համար։ Որոշ ինտերպրետատորներ, ձգտում են ավելի բարձր մակարդակի ծրագրերի խտացման`   օգտագործելով <nowiki/>[[բիթ]]-կողմնորոշված(այլ ոչ թե բայթ-կողմնորոշված ) ծրագրերի հիշողության ստրուկրուրաներ, որտեղ նշանների հրամանները հնարավոր է զբաղեցնեն 5 բիթ, անվանապես "16-bit" հաստատնները պահվում են փոփոխական-երկարության կոդում (<nowiki>{{lang-en| variable-length code }}</nowiki>, այն կոդ է, որը ցուցադրում է սկզբնական սիմվոլները  փոփոխականի թվերի բիթերով ) պահանջելով 3, 6, 10, կամ 18 բիթ և օպերանդի հասցեն ներառում է <բիթ օֆսեթ> (<nowiki>{{lang-en| bit offset}}</nowiki>)։
{| align="right" class="wikitable collapsible collapsed" style="text-align:left"
 
! Toy [[C (ծրագրավորման լեզու)|C]] expression interpreter
</syntaxhighlight>
|}
 
Ինտերպրետատորը կարող է օգտագործել նույն [[Լեքսիկական վերլուծություն|լեքսիական անալիզատորը]] և շարահյուսական վելուծություն, ինչպես կոմպիլյատորը և հետո ինտերպրետացնում է արդյուքը աբստրակտ շարահյուսության ծառի տեսքով(<nowiki>{{lang-en| abstract syntax tree }}</nowiki>)։
 
Ինտերպրետատորը կարող է օգտագործել նույն [[Լեքսիկական վերլուծություն|լեքսիական անալիզատորը]] և շարահյուսական վելուծություն, ինչպես կոմպիլյատորը և հետո ինտերպրետացնում է արդյուքը աբստրակտ շարահյուսության ծառի տեսքով(<nowiki>{{lang-en| abstract syntax tree }}</nowiki>
[[File:building_blocks.png|thumb|center|upright=2.0| Կոմպիլյացում և ինտերպրետացում ]]
 
 
 
=== Ռեգրեսիա ===
[[Ծրագրի կատարում | Ծրագրի կատարման]] համար ինտերպրետացիան չի կարող օգտագործվել միակ մեթոդ՝  թեև ինտերպրետատորը կարող է ինքն իրեն ինտերպրետացնել և այլն, ծրագրի անմիջական կատարման համր անհրաժեշտ է ստեկի ներքևի ինչ որ հատված, ինչպես [[Մշակիչ|պրոցեսսոր]]ը կարող է կատարել [[մեքենայկան կոդ]]ը  ։ 
 
 
 
== Վարիացիաներ ==
 
=== Բայթկոդ ինտերպրետատորներ ===
{{main|Բայթկոդ}}
Ինտերպրետացիայի և կոմպիլյացիայի միջև կան հնարավորությունների ամբողջ սպեկտոր, կախված կատարված վերլուծությունների քանակից՝ մինչև ծրագրի կատարումը։ Օրինակ Emacs Lisp-ը կոմպիլյացնում է բայթկոդը, որը չափազանց խտացված է (<nowiki>{{lang-en| compressed }}</nowiki>) և օպտիմիզացիան ներկայացնում է Լիսպի  սկզբանական, բայց ոչ մեքքենայական կոդ։ Այդ <կոմպիլյացված> կոդը հետո ինտերպրետացվում է բայթկոդ ինտերպրետատորով։ Այս դեպքում կոմպիլյացված կոդը մեքենայական կոդ է վիրտուալ մեքենայի համար, որը իրականցվում ոչ թե հարդվերում,այլ ինտերպրետատորի բայթկոդում։ Նույն մոտեցումը օգտագործվում է Forth կոդի դեպքում օգտգերծելով  Open Firmware համակարգում՝ սկազբանկան լեզուն կոմպլյացվում է <F code>-ի  (բայթկոդ), որը հետո ինտերպրետացվում է վիրտուալ մեքենայում։
 
Ինտերպրետացիայի և կոմպիլյացիայի միջև կան հնարավորությունների ամբողջ սպեկտոր, կախված կատարված վերլուծությունների քանակից՝ մինչև ծրագրի կատարումը։ Օրինակ Emacs Lisp-ը կոմպիլյացնում է բայթկոդը, որը չափազանց խտացված է (<nowiki>{{lang-en| compressed }}</nowiki>) և օպտիմիզացիան ներկայացնում է Լիսպի  սկզբանական, բայց ոչ մեքքենայական կոդ։ Այդ <կոմպիլյացված> կոդը հետո ինտերպրետացվում է բայթկոդ ինտերպրետատորով։ Այս դեպքում կոմպիլյացված կոդը մեքենայական կոդ է վիրտուալ մեքենայի համար, որը իրականցվում ոչ թե հարդվերում,այլ ինտերպրետատորի բայթկոդում։ Նույն մոտեցումը օգտագործվում է Forth կոդի դեպքում օգտգերծելով  Open Firmware համակարգում՝ սկազբանկան լեզուն կոմպլյացվում է <F code>-ի  (բայթկոդ), որը հետո ինտերպրետացվում է վիրտուալ մեքենայում։
 
 
 
=== Աբստրակտ շարահյուսության ծառ Ինտերպրատատորներ   ===
Ինտերպրետացիայի և կոմպիլյացիայի միջև, այլ  մոտոցում է, սկզբնական կոդի փոխակերպումը  օպտիմալցված  աբստրակտ շարահյուսության ծառի,  կոմպիլյացնելով ծրագիրը այդ ծառի կառուցվածքին, կամ օգտագործում է այն  <nowiki/>[[JIT-կոմպիլյացիա|դինամիկ]] գեներացնելով սեփական կոդ(<nowiki>{{lang-en| native code }}</nowiki> կամ մեքենայական  կոդ) ։ Այս մոտեցմամբ նախադասության  շարահյուսական  վերլուծությունը(<nowiki>{{lang-en|parse }}</nowiki>) կատարվում է միայն մեկ անգամ։  <nowiki/>[[JIT-կոմպիլյացիա|JIT-կոմպիլյյատերների]] համար աբստրակտ շարահյուսության ծառը (<nowiki>{{lang-en|AST }}</nowiki>) հանդիսանում է ավելի լավ միջանկյալ ձևաչափ, քան բայթկոդը։ Բացի այդ  <nowiki/>[[Ծրագրի կատարման ժամանակ]] այդ համակարգը ավելի լավ վերլուծություն է  կատարում։
 
Սակայն, ինտերպրետատորների համար աբստրակտ շարահյուսության ծառը (<nowiki>{{lang-en|AST }}</nowiki>) դառնում է պատճառ ավելի շատ վերադիր ծախսերի (<nowiki>{{lang-en|overhead }}</nowiki>), քան բայթկոդ ինտերպրետատորի դեպքում։ .<ref>[http://webkit.org/blog/189/announcing-squirrelfish/ Surfin' Safari - Blog Archive » Announcing SquirrelFish]. </ref>
 
Սակայն, ինտերպրետատորների համար աբստրակտ շարահյուսության ծառը (<nowiki>{{lang-en|AST }}</nowiki>) դառնում է պատճառ ավելի շատ վերադիր ծախսերի (<nowiki>{{lang-en|overhead }}</nowiki>), քան բայթկոդ ինտերպրետատորի դեպքում։ .<ref>[http://webkit.org/blog/189/announcing-squirrelfish/ Surfin' Safari - Blog Archive » Announcing SquirrelFish]. </ref>
 
=== JIT կոմպիլյացիան (Just-in-time compilation) ===
[[File:Compile.PNG|thumb|upright=1.87 |.NET կոպիլյատորով սկզբնական կոդը կոմպիլայցվում է ՛՛exe՛՛-ի կամ ՛՛dll՛՛-ի ]]
 
{{main|JIT կոմպիլյացիան}}
 
JIT կոմպիլյացիան տեխնալոգիա է,  որը բարձրացնում է ծրագրային համակարգերի արդյունավետությունը, օգտագործելով բայթկոդ, կոմպիլյացնում է այն մեքենայական կոդի կամ այլ ձևաչափի, [[ծրագրի կատարման ժամանակ]]։ Դա տալիս է էֆեկտիվություն սեփական կոդը աշխատեցնելիս, գործարկաման ժամանակի հաշվին և ավելացնում է հիշողության օգտագործումը երբ բայթկոդը կամ աբստրակտ շարահյուսության ծառը սկզբում կոմպիլյացվում են։ '' Ադապտիվ օպտիմիզացիան '' լրացուցիչ մեթոդ է, որում ինտերպրետատորը ուրվագծում է կատարվող ծրագիրը և կոմպիլյացնում է սեփական կոդում, առավել հաճախակի կատարվող մասերը։ Երկու մեթոդներն  էլ հին են, հայտնվել են այնպիսի լեզուներում ինչպիսին է ՝ [[Smalltalk]]-ը 1980թ․-ին։
 
 
 
 
 
=== Self-ինտերպրետատոր (Self-interpreter) ===
Համակարգչային լեզվի սահմանումը, որպես կանոն իրականցվում է աբստրակտ մեքենայով ({{lang-en | operational semantics }}) կամ մաթեմատիկակն ֆունկցիաներով({{lang-en| denotational semantics}})։ Լեզուները կարող են սահմնավել ինտերպրետատորով, որում բազային լեզվի ({{lang-en| host language }}) սեմանտիկան տրված է։ Self-ինտերպրետատորվ սահմանված լեզուները հիմնավորված չեն (չեն կարող սահմանել լեզուներ), բայց Self-ինտերպրետատորը ընթերցողին ներկայացնում է լեզվի արտայհայտչությունը և էլեգանտությունը։ Դա նաև թույլ է տալիս թարգմանչին ինտերպրետացնել իր սկզբնական կոդը, առաջին քայլը ուղվելով ինտերպրետացիայի արտացոլմանը։
Կարևոր ասպեկտ է Self-ինտերպրետատորի իրականացումը՝ ինտերպրետացվող լեզվի առանձնահատկությունը հադիսանում է արդյո՞ք նույն առանձնահատկություն՝ իրականցվող ինտերպրետատորի բազային լեզվում։
 
 
== Հավելվածներ ==
281

edits