How does Java Work

How does Java work

(UCSY IT Camp မှာပြောသွားတာတွေဖို.ပြန်ရေးပေးထားတာပါ)

Programming language တွေ implement လုပ်တဲ့အခါ compiler,interpreter, transpiler တွေသုံးပြီး လုပ်ရတယ်။ Compiler က source code ကိုယူတယ်ပြီးရင် output ကျတော့ native code , executable code ထုတ်တယ်။ ကောင်းတာက သူက မြန်တယ်။ မကောင်းတာက native platform တခုအတွက် ပဲ run လို.ရမယ် ဥပမာ Window C Compiler က ထွက်တဲ့ native exe သည် linux မှာသွား run လို.မရဘူး။

နောက်တခုက compiler တွေသည် runtime မှာပြောင်းလဲရတာ အရမ်းများတဲ့ dynamic language feature တွေကို implement လုပ်ရတာ အဆင်မပြေဘူး။ ဒါက သက်သက်ရေးထားတာရှိတယ် ရှာဖတ်ကြည့်စေချင်တယ်။ ဒါကြောင့် များသောအားဖြင့် dynamic programming langauge တွေကို interpreter သုံးပြီး implement လုပ်တယ်။

Transpiler ကကျတော့ high level source Program တခု ယူပြီး output အနေနဲ. သူ.ထက် abstraction နိမ့်တဲ့ language နဲ. source code ပြန်ထုတ်ပေးတာ ။ ဥပမာ ES6 ကိုယူပြီး ES5 ထုတ်ပေးတာမျိုး TypeScript ကိုယူပြီး JS ထုတ်ပေးတာမျိုး။

ခုနက Compiler တွေ အားနည်းချက်က native platform တခုအပေါ်မှာပဲ run လို.ရမယ်။ အဲ့တော့ platform အားလုံးမှာ semantic မပြောင်းပဲ run လို.ရချင်တယ်(ဥပမာ window မှာ int သည် 32 bit ဖြစ်ပြီး Linux မှာ တမျိုးဖြစ်မနေတာ network byte order, little edian , big edian ကွာတာတွေ ဖြစ်မနေတာ same program သည် ဘယ် platform မှာ run သည်ဖြစ်စေ runtime semantic တူနေတာ ) ။ အဲ့တော့ Java က ဘာလုပ်ရလဲဆိုတော့ native executable code ထုတ်မဲ့အစား Java Compiler ကနေ byte code ထုတ်လိုက်တယ်။

တကယ်တော့ byte code ဆိုတာ abstract representation တွေပဲ assembly လို abstraction level ပေါ့။ Java byte code ကျတော့ assembly လို register based instruction မဟုတ်ပဲ stack based instruction တွေပေါ့။ Stack base byte code ပေါ့။ ဘာလို.ဆိုတော့ Stack based virtual machine code တွေသည် implement လုပ်ရတာ လွယ်တယ်။

အဲ့တော့ Java သည် ၂ ပိုင်းနဲ.အလုပ်လုပ်တယ်ပြောရမယ်။ ပထမတခုက Java Compiler, javac command ပေါ့ သူက Java source code ကနေ bytecode ထုတ်တယ်။ အဲ့ဒီ bytecode ကို run ဖို.အတွက် Virtual Machine လိုတယ်။ အဲ့တာကို Java Virtual Machine လို.ခေါ်တယ်။ JVM က bytecode ကိုယူပြီး ဆိုင်ရာ platform ပေါ်မှာ run လို.ရအောင် execute လုပ်လိုရအောင် လုပ်ပေးတယ်။

JVM Detail ကို series အလိုက်ရေးထားတာရှိတယ်။ ( ၉ပိုင်းရေးထားတာ)

အဲ့တော့ Java Compiler ဘယ်လိုအလုပ်လုပ်သလဲဆိုတာကို Open JDK ကနေ ယူထားတယ်. အောက်ကပုံပေါ့။

သူ.မှာ ဒီအဆင့်တွေပါတယ်။

Parse :

ဒီအဆင့်က Java Source code ကိုဖတ်တယ် ပြီးရင် parse လုပ်တယ်။ Grammar rule တွေအရ parse tree ဆွဲထုတ်မယ်။ နောက် parse tree ကို prune လုပ်ပြီး ပိုတိုပြီး process လုပ်ရလွယ်တဲ့ abstract syntax tree ဆောက်မယ်။ ဒီအဆင့်က Grammar, Syntax checking အဆင့်လုပ်ပေးရတဲ့ကောင်ပဲ။အထဲမှာတကယ်တော့ error ဖြစ်ရင် အကြောင်းကြားတာ။ Parsing state ကို recovery လုပ်တာတွေပါဦးမယ်။

Enter:

ခုနက Parse tree ကို traverse လုပ်ပြီး type checking, name type resolution တွေလုပ်ဖို. ဘယ် class ထဲမှာ ဘယ် field တွေပါတယ်။ သူတို.က ဘာ type, ဘယ်လို access modifier ရှိတယ် အဲ့ကောင်တွေကို Symbol table ထဲ ထဲ့သိမ်းရတယ်။

Process annotations:

Java မှာ annotation တွေပါတော့ ဒီအဆင့်ကအဲ့ဒီ processing တွေကိုလုပ်တယ်။

Attribute

ဒီအဆင့်က ဥပမာ

int a;

a= “Hello”;

ဒါမျိုးဆို Grammar အရမှန်တယ် ဒါပေမဲ့ type checking အရမှားတယ်။ အဲ့လိုကောင်တွေ ကို စစ်လို.၇အောင် လုပ်ပေးရတာ။ AST ကနေ type information တွေ attribute တွေကို လိုအပ်တဲ့နေရာဆီ ရောက်အောင် ယူရတာ လှမ်းပို.ရတာ။

Desugar:

AST က ရှုပ်နေနိုင်သေးတယ် နောက်ပြီး Optimization တွေ မပါသေးဘူး ဥပမာ 5+2 ဆိုရင် တခါတည်း 7 ဆိုပြီး rewrite လုပ်လို.ရတယ် အဲ့တာကို desugaring လုပ်တာလို.ခေါ်တာ။

Generate:

ဒီအဆင့်က ခုနက Grammar မှန်ပြီး static semantic မှန်ပြီး type checking လုပ်ပြီး အားလုံးအဆင်ပြေတယ်ဆိုရင် AST ကနေ JVM နားလည်တဲ့ bytecode ကိုထုတ်ပေးတယ်။ အဲ့ကနေ Java class file တွေထွက်လာမယ်။

ဥပမာ ဒီ expression လေးပေါ့။ a = b + c* d;

သူ.ကို parse ပြီး AST ထုတ်ရင် ရင်ပုံထဲကလို tree ရမယ်။ အဲ့ကောင်လေးကို post order (left, right, root ) အတိုင်း traverse လုပ်ပြီး byte code ထုတ်ရင် အောက်က ကောင်လိုရမယ်။JVM bytecode လို type information တော့မထဲ့တော့ဘူး။ဒီလိုပေါ့။

Push b

Push c

Push d

Mult

Add

Store A

အဲ့ဒီ byte code ကုိ JVM က execute လုပ္မယ္ဆုိပါစုိ.

a = b + c* d; (b =2, c=3, d=5)

push b

Stack ပေါ်ကို b တင်တော့ [2] ရမယ်

နောက် push c ဆိုတော့ [2,3]

နောက် push d ဆိုတော့ [2,3,5]

mult ဆိုတော့ stack top က ၂ခုကို pop လုပ်မြှောက်ပြီး ပြန်ထဲ့ ဒါဆို ထိပ်ဆုံးသည် 3,5 ပြန်ထဲ့လိုက်ရင် [2,15]

နောက် add ဒါဆို stack ပေါ်က top ၂ခုကို pop လုပ်ပြီး ပေါင်းပြန်ထဲ့ရင် [17]

ရမယ်

store A ဒါဆို stack ထိပ်ဆုံးက 17 ကို a ဆိုတဲ့နေရာမှာ ထဲ့မယ်။ အဲ့လိုလုပ်သွားတာ အကျယ်က JVM series မှာဖတ်စေချင်တယ်။