Turing Programming Training Center

Instructor Profile ‌ပေါ့ အရင်ရေးဖူးတာ ထပ်ဖြည့်တာ ဘာမှတော့သိပ်မထူးသွား။ (စာသင်တော့ သင်ခံရမဲ့သူတွေလဲ သူတို့သင့်မဲ့သူဘယ်သူဆိုတာသိဖို့လိုလို့ update ပေါ့)

စာသင်မယ်ဆိုတော့ page မှာတင်ဖို. Coach profile ပေါ့။ ကိုယ့်ဂုဏ်ကိုဖော် မသူတော် လုပ်ရတာပေါ့။

နာမည်က သက်ခိုင်။ ၂၀၀၂ မှာ UCSY ရန်ကုန်ကွန်ပျူတာ တက္ကသိုလ်ကို စတတ်တယ်။ ၂၀၀၉ မှာ M.C.Sc ပြီးတယ်။ Master Thesis အတွက် ကျမ်းကို The Development of a new Object Oriented Programming Language ဆိုတဲ့ ခေါင်းစဉ်နဲ. တင်ခဲ့တယ်။ ဘာအကြောင်းအရာ တွေလဲဆိုတော့ Object Oriented Design Pattern တွေကို Programming Language level မှာ တခါတည်း တန်း support လုပ်နိုင်အောင် Special Language Construct တွေပါတဲ့ Object Oriented Programming Language တခုတည်ဆောက်တဲ့အကြောင်းပါပဲ။ Fully Object Oriented Programming Language ဖြစ်တဲ့အပြင် အဲ့တုန်းက ခေတ်ပြိုင် programing language တွေရဲ. အားနည်းချက်တွေကို တတ်နိုင်သမျှ ဖာထေးပြီး design ချခဲ့ပါတယ်။ Syntax ကတော့ C Based syntax ကိုသုံးပါတယ်။
အဲ့ဒီ Language အတွက် ကိုယ်ပိုင် Compiler (Java နဲ.ရေးတယ်) Virtual Machine (C++ နဲ.ရေးပါတယ်), Editor (Java Swing ကိုသုံးပြီးရေးတယ်) ကိုတည်ဆောက်ခဲ့ရပါတယ်။ သုံးနှစ်လောက် အချိန်ယူ လုပ်ခဲ့ပါတယ်။ Thesis ကတော့ ဒီမှာသွားကြည့်လို.ရပါတယ်။

https://www.dropbox.com/s/tq6f2lyathgatqn/MasterThesis.pdf
Code ကတော့ ဒီမှာသွားကြည့်လို.ရပါတယ်။ (ဗရုတ်သုတ်တော့နည်းနည်းနိုင်တာပေါ့ )
https://github.com/mrthetkhine/UCSYLang
Window ပေါ်မှာ run နိုင်ပါတယ်။

Mac ဖို့ကတော့ ဒီကောင့်သုံးရင် run လို့ရပါမယ်
https://github.com/mrthetkhine/UVMForMac

Master ပြီးတော့ ဆက်လေ့လာဖြစ်တာက 2009 ကနေ ခုထိ AI , Machine Learning အစရှိတာတွေဖြစ်ပါတယ်။
2012 မှာ သိုင်းလောကမှာ zero ဆိုပြီး ကျင်လည်ခဲ့ဖူးပါတယ်။
Professionally စိတ်ဝင်စားတဲ့ field တွေက system programming, programming language design, implementation,software engineering, architecture, AI, deep learning. အစရှိတာတွေပါပဲ။

လောလောဆယ် financial institution တခုမှာDyCTO အနေနဲ့လုပ်ကိုင်နေပါတယ်။

တခြား ဝါသနာပါတာတွေကတော့ လောကကြီး အကြောင်း ၊ လူတွေ အကြောင်း၊လူ.စိတ်တွေအကြောင်း၊ သဘာဝ တရားတွေ အကြောင်းလေ့လာတာရယ်၊ အလှမွေးငါးတွေ မွေးတာ၊ ဓာတ်ပုံရိုက်တာနဲ. ခရီးသွားတာရယ်ပဲဖြစ်ပါတယ်။
အားလပ်ချိန်မှာ စိတ်ဝင်စားတဲ့ technical content တွေရေးပါတယ် Programming Channel Group ရဲ. admin တဦးလဲဖြစ်ပါတယ်။

GitHub - mrthetkhine/UVMForMac: UVM port for Mac OS UVM port for Mac OS. Contribute to mrthetkhine/UVMForMac development by creating an account on GitHub.

**𝐀𝐝𝐯𝐚𝐧𝐜𝐞𝐝 𝐒𝐨𝐟𝐭𝐰𝐚𝐫𝐞 𝐄𝐧𝐠𝐢𝐧𝐞𝐞𝐫𝐢𝐧𝐠 & 𝐃𝐞𝐬𝐢𝐠𝐧 𝐂𝐨𝐮𝐫𝐬𝐞** (𝐁𝐚𝐭𝐜𝐡 𝟖)

𝟐𝟎𝟐𝟔 𝐀𝐮𝐠𝐮𝐬𝐭 𝟓 စမဲ့ Advanced SE တန်းပါ

အဓိက Code ရေးတတ်ပြီး design concept လိုနေတာတွေ quality code, design, TDD, refactoring စတာတွေ အတွက်ပါ။
အဓိက programming မှာနေရာတခုရပြီးလူတွေအဖို့ software design & design thinking စတာတွေကို OOP &FP Clean Code, TDD, Refactoring စတာတွေနဲ့သင်ပေးဖို့ပါ။
Java & JS ကိုနားလည်ထားရပါမယ်။ (Java မရလဲ static type language တခုခုကိုနားလည်ရင်အဆင်ပြေပါတယ်)

𝐂𝐨𝐮𝐫𝐬𝐞 𝐨𝐮𝐭𝐥𝐢𝐧𝐞

🎓 C𝐥𝐞𝐚𝐧 𝐂𝐨𝐝𝐞
✅ 𝐍𝐚𝐦𝐢𝐧𝐠 𝐜𝐨𝐧𝐯𝐞𝐧𝐭𝐢𝐨𝐧𝐬
✅ 𝐖𝐫𝐢𝐭𝐢𝐧𝐠 𝐅𝐮𝐧𝐜𝐭𝐢𝐨𝐧𝐬
✅ 𝐂𝐨𝐦𝐦𝐞𝐧𝐭𝐬 𝐚𝐧𝐝 𝐮𝐬𝐚𝐠𝐞 𝐠𝐮𝐢𝐝𝐞𝐥𝐢𝐧𝐞𝐬
✅ 𝐍𝐚𝐦𝐢𝐧𝐠 𝐜𝐨𝐧𝐯𝐞𝐧𝐭𝐢𝐨𝐧𝐬
✅ 𝐖𝐫𝐢𝐭𝐢𝐧𝐠 𝐅𝐮𝐧𝐜𝐭𝐢𝐨𝐧𝐬
✅ 𝐂𝐨𝐦𝐦𝐞𝐧𝐭𝐬 𝐚𝐧𝐝 𝐮𝐬𝐚𝐠𝐞 𝐠𝐮𝐢𝐝𝐞𝐥𝐢𝐧𝐞𝐬
✅ 𝐅𝐨𝐫𝐦𝐚𝐭𝐭𝐢𝐧𝐠
✅ 𝐎𝐛𝐣𝐞𝐜𝐭𝐬 & 𝐝𝐚𝐭𝐚 𝐬𝐭𝐫𝐮𝐜𝐭𝐮𝐫𝐞𝐬
✅ 𝐇𝐨𝐰 𝐭𝐨 𝐇𝐚𝐧𝐝𝐥𝐞 𝐄𝐫𝐫𝐨𝐫𝐬
✅ 𝐈𝐧𝐭𝐞𝐫𝐟𝐚𝐜𝐞 𝐁𝐨𝐮𝐧𝐝𝐚𝐫𝐢𝐞𝐬 𝐞𝐭𝐜

🎓 𝐎𝐎 𝐏𝐫𝐢𝐧𝐜𝐢𝐩𝐥𝐞 & 𝐃𝐞𝐬𝐢𝐠𝐧 𝐏𝐚𝐭𝐭𝐞𝐫𝐧 & 𝐀𝐫𝐜𝐡𝐢𝐭𝐞𝐜𝐭𝐮𝐫𝐞 𝐏𝐚𝐭𝐭𝐞𝐫𝐧
✅ 𝐁𝐚𝐬𝐢𝐜 𝐎𝐎𝐏
✅ 𝐒𝐎𝐋𝐈𝐃 𝐏𝐫𝐢𝐧𝐜𝐢𝐩𝐥𝐞
✅ 𝐌𝐚𝐣𝐨𝐫 𝐆𝐨𝐅 𝐃𝐞𝐬𝐢𝐠𝐧 𝐏𝐚𝐭𝐭𝐞𝐫𝐧 (𝐚𝐭 𝐥𝐞𝐚𝐬𝐭 𝐚𝐫𝐨𝐮𝐧𝐝 𝟐𝟎 𝐩𝐚𝐭𝐭𝐞𝐫𝐧)
✅ 𝐂𝐫𝐞𝐚𝐭𝐢𝐨𝐧𝐚𝐥 𝐩𝐚𝐭𝐭𝐞𝐫𝐧𝐬
✅ 𝐁𝐞𝐡𝐚𝐯𝐢𝐨𝐫𝐚𝐥 𝐩𝐚𝐭𝐭𝐞𝐫𝐧𝐬
✅ 𝐒𝐭𝐫𝐮𝐜𝐭𝐮𝐫𝐚𝐥 𝐩𝐚𝐭𝐭𝐞𝐫𝐧𝐬
✅ 𝐖𝐢𝐝𝐞𝐥𝐲 𝐮𝐬𝐞𝐝 𝐀𝐫𝐜𝐡𝐢𝐭𝐞𝐜𝐭𝐮𝐫𝐞 𝐏𝐚𝐭𝐭𝐞𝐫𝐧

🎓 𝐅𝐮𝐧𝐜𝐭𝐢𝐨𝐧𝐚𝐥 𝐩𝐫𝐨𝐠𝐫𝐚𝐦𝐦𝐢𝐧𝐠
✅ 𝐅𝐢𝐫𝐬𝐭 𝐂𝐥𝐚𝐬𝐬 𝐅𝐮𝐧𝐜𝐭𝐢𝐨𝐧
✅ 𝐇𝐢𝐠𝐡𝐞𝐫 𝐎𝐫𝐝𝐞𝐫 𝐅𝐮𝐧𝐜𝐭𝐢𝐨𝐧
✅ 𝐏𝐮𝐫𝐞 𝐅𝐮𝐧𝐜𝐭𝐢𝐨𝐧
✅ 𝐂𝐚𝐭𝐞𝐠𝐨𝐫𝐲 𝐓𝐡𝐞𝐨𝐫𝐲 (𝐌𝐨𝐧𝐨𝐢𝐝, 𝐅𝐮𝐧𝐜𝐭𝐨𝐫, 𝐌𝐨𝐧𝐨𝐚𝐝 (𝐌𝐚𝐲𝐁𝐞 𝐌𝐨𝐧𝐚𝐝, 𝐄𝐢𝐭𝐡𝐞𝐫))
✅ 𝐅𝐮𝐧𝐜𝐭𝐢𝐨𝐧𝐚𝐥 𝐞𝐫𝐫𝐨𝐫 𝐡𝐚𝐧𝐝𝐥𝐢𝐧𝐠
✅ 𝐑𝐚𝐢𝐥𝐰𝐚𝐲 𝐩𝐫𝐨𝐠𝐫𝐚𝐦𝐦𝐢𝐧𝐠

🎓 𝐌𝐞𝐚𝐬𝐮𝐫𝐢𝐧𝐠 𝐂𝐨𝐝𝐞 𝐐𝐮𝐚𝐥𝐢𝐭𝐲
✅ 𝐂𝐨𝐝𝐞 𝐪𝐮𝐚𝐥𝐢𝐭𝐲 𝐦𝐞𝐭𝐫𝐢𝐜
✅ 𝐌𝐚𝐢𝐧𝐭𝐚𝐢𝐧𝐚𝐛𝐢𝐥𝐢𝐭𝐲 𝐈𝐧𝐝𝐞𝐱
✅ 𝐂𝐲𝐜𝐥𝐨𝐦𝐚𝐭𝐢𝐜 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲
✅ 𝐃𝐞𝐩𝐭𝐡 𝐨𝐟 𝐈𝐧𝐡𝐞𝐫𝐢𝐭𝐚𝐧𝐜𝐞
✅ 𝐂𝐥𝐚𝐬𝐬 𝐂𝐨𝐮𝐩𝐥𝐢𝐧𝐠
✅ 𝐋𝐢𝐧𝐞𝐬 𝐨𝐟 𝐒𝐨𝐮𝐫𝐜𝐞 𝐜𝐨𝐝𝐞

🎓 𝐓𝐞𝐬𝐭 𝐃𝐫𝐢𝐯𝐞𝐧 𝐃𝐞𝐯𝐞𝐥𝐨𝐩𝐦𝐞𝐧𝐭
✅ 𝐖𝐡𝐲 𝐀𝐝𝐨𝐩𝐭 𝐓𝐃𝐃 𝐁𝐞𝐧𝐞𝐟𝐢𝐭𝐬 𝐨𝐟 𝐓𝐃𝐃
✅ 𝐓𝐞𝐬𝐭𝐢𝐧𝐠 𝐂𝐨𝐧𝐜𝐞𝐩𝐭𝐬 (𝐓𝐞𝐬𝐭 𝐩𝐥𝐚𝐧, 𝐮𝐧𝐢𝐭 𝐭𝐞𝐬𝐭𝐢𝐧𝐠, 𝐢𝐧𝐭𝐞𝐫𝐠𝐫𝐚𝐭𝐢𝐨𝐧 𝐭𝐞𝐬𝐭𝐢𝐧𝐠,𝐀𝐜𝐜𝐩𝐞𝐭𝐚𝐧𝐜𝐞 𝐭𝐞𝐬𝐭𝐢𝐧𝐠)
✅ 𝐓𝐃𝐃 𝐂𝐨𝐧𝐜𝐞𝐩𝐭𝐬
✅ 𝐓𝐃𝐃 𝐏𝐚𝐭𝐭𝐞𝐫𝐧𝐬 𝐓𝐃𝐃 𝐁𝐞𝐬𝐭 𝐏𝐫𝐚𝐜𝐭𝐢𝐜𝐞𝐬
✅ 𝐓𝐞𝐬𝐭𝐢𝐧𝐠 𝐓𝐨𝐨𝐥 (𝐉𝐮𝐧𝐢𝐭, 𝐌𝐨𝐜𝐤𝐢𝐭𝐨,𝐉𝐚𝐬𝐦𝐢𝐧𝐞)
✅ 𝐓𝐃𝐃 𝐊𝐚𝐭𝐚 (𝐖𝐞𝐛 𝐒𝐞𝐫𝐯𝐞𝐫 𝐢𝐧 𝐓𝐃𝐃, 𝐁𝐢𝐧𝐚𝐫𝐲 𝐒𝐞𝐚𝐫𝐜𝐡 𝐓𝐫𝐞𝐞, 𝐁𝐒𝐓 𝐓𝐫𝐞𝐞 𝐓𝐫𝐚𝐯𝐞𝐫𝐬𝐚𝐥 (𝐏𝐫𝐞𝐨𝐫𝐝𝐞𝐫,𝐈𝐧𝐨𝐫𝐝𝐞𝐫,𝐏𝐨𝐬𝐭𝐨𝐫𝐝𝐞𝐫))

🎓 𝐑𝐞𝐟𝐚𝐜𝐭𝐨𝐫𝐢𝐧𝐠
✅ 𝐏𝐫𝐢𝐧𝐜𝐢𝐩𝐥𝐞𝐬 𝐢𝐧 𝐑𝐞𝐟𝐚𝐜𝐭𝐨𝐫𝐢𝐧𝐠
✅ 𝐂𝐨𝐝𝐞 𝐒𝐦𝐞𝐥𝐥( 𝐃𝐮𝐩𝐥𝐢𝐜𝐚𝐭𝐞𝐝 𝐂𝐨𝐝𝐞,𝐋𝐨𝐧𝐠 𝐌𝐞𝐭𝐡𝐨𝐝,𝐋𝐚𝐫𝐠𝐞 𝐂𝐥𝐚𝐬𝐬,𝐋𝐨𝐧𝐠 𝐏𝐚𝐫𝐚𝐦𝐞𝐭𝐞𝐫 𝐋𝐢𝐬𝐭,𝐃𝐢𝐯𝐞𝐫𝐠𝐞𝐧𝐭 𝐂𝐡𝐚𝐧𝐠𝐞,𝐒𝐡𝐨𝐭𝐠𝐮𝐧 𝐒𝐮𝐫𝐠𝐞𝐫𝐲 𝐞𝐭𝐜)
✅ 𝐑𝐞𝐟𝐚𝐜𝐭𝐨𝐫𝐢𝐧𝐠 𝐌𝐞𝐭𝐡𝐨𝐝(𝐂𝐨𝐦𝐩𝐨𝐬𝐢𝐧𝐠 𝐌𝐞𝐭𝐡𝐨𝐝𝐬,𝐌𝐨𝐯𝐢𝐧𝐠 𝐅𝐞𝐚𝐭𝐮𝐫𝐞𝐬 𝐁𝐞𝐭𝐰𝐞𝐞𝐧 𝐎𝐛𝐣𝐞𝐜𝐭𝐬,𝐎𝐫𝐠𝐚𝐧𝐢𝐳𝐢𝐧𝐠 𝐃𝐚𝐭𝐚 𝐞𝐭𝐜)
✅ 𝐑𝐞𝐟𝐚𝐜𝐭𝐨𝐫𝐢𝐧𝐠 𝐓𝐨𝐨𝐥
✅ 𝐅𝐮𝐧𝐜𝐭𝐢𝐨𝐧𝐚𝐥 𝐑𝐞𝐚𝐜𝐭𝐢𝐯𝐞 𝐏𝐫𝐨𝐠𝐫𝐚𝐦𝐦𝐢𝐧𝐠
✅ 𝐀𝐫𝐜𝐡𝐢𝐭𝐞𝐜𝐭𝐮𝐫𝐚𝐥 𝐏𝐚𝐭𝐭𝐞𝐫𝐧
✅ 𝐂𝐥𝐨𝐮𝐝 𝐝𝐞𝐬𝐢𝐠𝐧 𝐩𝐚𝐭𝐭𝐞𝐫𝐧

အချိန် ၅ လ လောက်ကြာပါမယ်။ (ပိုလဲကြာနိုင်ပါတယ်)
𝟐𝟎𝟐𝟔 𝐀𝐮𝐠𝐮𝐬𝐭 𝟓 ရက်နေ့စပါမယ်။

⏰ Wednesday, Thursday 7:30 PM to 9:30 PM ဖြစ်ပါမယ်
သင်တန်းကြေး 3 သိန်းဖြစ်ပါမယ်။
Fully online course ဖြစ်ပါမယ်။ (Facebook Private group ကနေ live မှာဖြစ်ပါတယ်,Record တွေကို telegram ပေါ်တင်ပေးပါမယ်)

Page မှာစာရင်းသွင်းလို့ရပါပြီ။

Gentle Introduction to Object Oriented Programming Part 2
Inheritance

OO paradigm မှာမပါမဖြစ်တဲ့နောက် feature တစ်ခုက Inheritance ပါ။ Inheritance ကဘာလုပ်ဆောင်မှု.တွေကိုခွင့်ပေးသလဲဆိုတော့ existing class တခုကနေ code reuse သို.မဟုတ် နဂိုမူလရှိတဲ့ base class ကို extend လုပ်ပြီး functionality ကို modify လုပ်တာဖြည့်စွက်တာတွေကို ခွင့်ပေးပါတယ်။ Inheirtance ကိုသုံးပြီး နဂိုမူရင်း base class ရဲ. source code ကိုမထိပဲ ပြင်လို.ရနိုင်ပါတယ် (extend လုပ်ပြီးပေါ့)။အဲ့လို non-destructive modification တွေဟာ modern software development မှာမဖြစ်မနေကိုလိုအပ်ပါတယ်။ Modified class ကို base class နေရာမှာသုံးလို.ရတာကြောင့် software maintenance ကိုပိုမိုလွယ်ကူစေပါတယ်။ Inheritance ရဲ. major usage က ၂ခုရှိပါတယ် design မှာသုံးလို.ရသလို implementation အတွက်လဲသုံးပါတယ်။ အဲ့ဒါတွေကတော့

Inheritance as conceptual modelling
Inheritance as incremental program modification


OOP ရဲ.တခြား paradigm တွေထက် popular ဖြစ်ရတဲ့အကြောင်းရင်းက Object Orientation ဟာ implementation သက်သက်သာ မဟုတ်ပဲနဲ. modelling or design အတွက်ပါသုံးလို.ရလို.ဖြစ်ပါတယ်။ Real world problem တွေကို OO thinking နဲ. model ချတဲ့အခါမှာပိုမိုလွယ်ကူပါတယ်။ လူတွေဟာ အရာဝတ္ထုတွေ အကြောင်းအရာတွေကို ခွဲခြားစိတ်ဖြာတယ် (classification ဥပမာ လူဆိုတာ သတ္တဝါ တိရစ္ဆာန်ကလဲ သတ္တဝါ) ၊ generalization (ဥပမာ car engine ကလဲစက် motor engine ဆိုတာလဲ စက်)၊ grouping,composition အစရှိတာတွေနဲ.တွေးခေါ်ကြပါတယ်။ ခုနကပြောတဲ့ classification၊ generalization၊ specialization အစရှိတာတွေကို OO paradigm မှာ easiliy model လုပ်လို.ရပါတယ်။ classification ကို class contruct နဲ.လုပ်ကြပါတယ်။ Generalization နဲ. Specialization ကိုတော့ inheritance နဲ. model လုပ်ကြပါတယ်။ Grouping နဲ. composition ကိုတော့ class တွေမှာ တခြား classes တွေရဲ. reference variable တွေထဲ့သွင်းခြင်းအားဖြင့် သုံးကြပါတယ်။

Inheritance as conceptual modelling
Inheritance ကို Generalization, Specialization အတွက်သုံးပြီဆိုရင် ဒါဟာ inheritance as coneptual modelling ပါ။ Base class or parent class ကို generalized classes လို.ခေါ်ပြီးတော့ child class ကိုတော့ specialized class လို.ခေါ်ပါတယ်။ Conceptual modelling လုပ်မယ်ဆိုရင် base class နဲ. drived class ဟာ taxonomy အရတူရမှာပါ။ ဥပမာ Teacher, Doctor နဲ. Human ဆိုတာဟာ taxonomy အရတူပါတယ်။ Hierarchical relationship ရှိတာကိုပြောချင်တာပါ။ Teacher, Doctor သည် is a kind of Human ပါပဲ။ Taxonomy အရ မတူဘူးဆိုရင် Generalization Specialization မလုပ်သင့်ပါဘူး ဥပမာ Bird နဲ. Aeroplane သည် ပျံတာချင်းတူပေမဲ့ သူတို.ကို Inheritance နဲ.ချိတ်လို.မရပါဘူး။ သူတို.က taxonomy အရမတူပါဘူး။ Inheritance လို conceptualization လုပ်ပေးနိုင်တဲ့နောက်တခုက တော့ Subtyping ပါ။Subtyping ဆိုတာ programming lanaugag ကနေပေးထားတဲ့ feature တွေကိုသုံးပြီး type တခု သည် အခြား type တခုရဲ. subtype ဖြစ်ပါတယ်ဆိုပြီးသုံးတာပါ။ Base type နေရာမှာ based type ကိုအခြေခံထားတဲ့ တခြား type ကိုအစားထိုးပြီးသုံးလို.ရပါတယ်။ Subtyping ကို type polymorphism လို.လဲသုံးကြပါသေးတယ် ။ Java, C # တို.မှာဆိုရင် interface construct ကိုထဲ့ပေးထားပါတယ်။ သူ.ကိုထဲ့ပေးထားရတဲ့အကြောင်းရင်းက conceptual modelling အရ taxonomy မတူတဲ့ကောင်တွေကို polymorphic လုပ်ချင်ရင်သုံးဖို.ပါ။ Java programmer တော်တော်များများ က abstract class နဲ. interface ဘာကွာလဲမေးလိုက်ရင် ရေရေရာရာကွဲပြားတဲ့အဖြေကို မဖြေနိုင်ကြပါဘူး။ အဓိက ကွာခြားချက်က taxonomy တူမယ်ဆိုရင် abstract class ကိုသုံးပြီး inheritance နဲ.ဖြေရှင်းမယ် မတူဘူးဆိုရင် subtyping ကို သုံးပြီင်္း interface နဲ. design လုပ်ရမှာပါ။ ဥပမာ work ဆိုတဲ့ method ကို polymorphic ဖြစ်အောင်လုပ်ချင်တယ်ဆိုပါစို. Teacher မှာရော Doctor မှာရော လုပ်ချင်တာဆိုရင် သူတို. ၂ခုဟာ taxonomy အရတူတဲ့အတွက် abstract class ဒါမှမဟုတ် ရိုးရိုး class သုံးပြီး inheritance နဲ. model လုပ်ရမှာပါ။ Fly ဆိုတဲ့ method ကို Bird နဲ. Aeroplane အတွက် polymorphism လုပ်ချင်တယ်ဆိုရင် သူတို. ၂ ခုဟာ taxonomy မတူတဲ့အတွက် Flyable ဆိုတဲ့ interface တခုထားပြီး model လုပ်ရမှာပါ။ Static type language တွေမှာ polymorphic operation တွေလုပ်ဖို. subtype တွေဖြစ်မှ လုပ်လို.ရပါတယ်။ Subtype မဟုတ်ရင် method ရှိနေလဲ ခေါ်လို.မရပါဘူး။ Dynamic language တွေမှာ duck typing ကိုပေးထားတဲ့အတွက် အဲ့လိုခေါ်လို.ရပါတယ်။ ဒါပေမဲ့ PHP လို dynamic language ဖြစ်တယ် duck typing ရတဲ့ language မှာ interface ကိုထဲ့ပေးထားတာဟာ conceptual modelling အရ subtyping ကိုသုံးစေချင်လို.ဖြစ်ပါတယ်။ နောက်တခုက normal class နဲ. abstract class ဘယ်လို usage ခွဲမလဲပေါ့ ။ Parent ကနေပဲ child က code တွေကို one direction ခေါ်ချင်ရင် hook အနေနဲ.ထားချင်ရင် abstract class ကိုသုံးပါတယ် မဟုတ်ရင် both direction ခေါ်ချင်ရင်တော့ normal class ကိုသုံးပြီး model လုပ်လို.ရပါတယ်။

Inheritance as incremental program modification
Inheritance as incremenatal program modification ဆိုတာ base class ရဲ. source code ကိုမပြင်ပဲနဲ. သူ.ကို implementation အရ ပြင်ချင်တဲ့အခါမှာ extend လုပ်ပြီးသုံးတာမျိုးပါ။ ဥပမာ Java မှာဆို window frame တခုဆောက်ချင်ရင် JFrame ကို extend လုပ်တာမျိုးပါပဲ။ ဒါကတော့ implementation အတွက်သုံးတာပါ။ တခါတလေမှာကိုပြင်ချင်တဲ့ source code ကိုမရနိုင်လို. binary class file ပဲရတဲ့အတွက် သူ. functionality ကို reuse လုပ်ချင်တာဖြစ်ဖြစ် modify လုပ်ချင်တာဖြစ်ဖြစ်သုံးတာမျိုးကိုလဲ ဒီနည်းထဲမှာအကျုံးဝင်ပါတယ်။ Modification ကိုပေးတဲ့နေရာမှာ language တခုနဲ.တခုမတူပါဘူး။ Inheritance breaks Encapsulation ဆိုတာလဲရှိပါတယ်။ ဘာကိုဆိုချင်တာလဲဆိုတော့ inheritance ကိုသုံးတာလွဲခဲ့ရင် သူဟာ parent classes ရဲ. function တွေကို တလွဲသုံးမိရင် encapsulation ဆိုတာကို ချိုးဖောက်တာဖြစ်နိုင်ပါတယ်။ သတိထားရမှာက parent classes ရဲ. encapsulation ကိုမထိအောင်သုံးရမှာပါ။ Favour inhertiance over composition ဆိုတာလဲရှိပါသေးတယ်။ တချို.က code reuse လုပ်ချင်ယုံသက်သက်နဲ. inheritance ကိုသုံးကြပါတယ် ။ taxonomy အရ မတူရင်သော်လည်းကောင်း modifcation or added functionality မထဲ့နိုင်ရင်သော်လည်းကောင်း အဲ့လိုသုံးတာမှားပါတယ်။ Code reuse လုပ်ချင်ရင် composition ကိုသုံးပါ။ ဘာလို.လဲဆိုတော့ inheritance hierarchicy များလာတာနဲ.အမျှ classes တွေဟာ dependency များလာပါတယ်။ Base class တခုကို ပြောင်းလိုက်တာနဲ. အောက်က child classes တွေမှာပါ effect ဖြစ်နိုင်ပါတယ်။ Composition ဆိုတာက ကိုသုံးလို.တဲ့ class ကို reference variable သုံးပြီး ယူသုံးတာပါပဲ။

Single Inheritance vs Multiple Inheritance
C++ မှာတော့ multiple inheritance ကို support လုပ်ပါတယ်။ Class တခုဟာ တခုထက်ပိုသော Base class တွေရှိနိုင်ပါတယ်။ Java,C # တို.မှာတော့ single inheritance ပဲခွင့်ပေးထားပါတယ်။

Class Inheritance Versus Prototype Inheritance
Programming language တွေဟာ inheritance ကို support လုပ်တဲ့ပုံစံချင်းမတူပါဘူး။ အဓိက ကွဲပြားတဲ့ပုံစံ ၂ခုက classical inheritance နဲ. prototypical inheritance ပဲဖြစ်ကြပါတယ်။

Classical Inheritance
Java,C++,C # တို.လို language တွေမှာ support လုပ်တဲ့ inheritance ပုံစံကို classical inheritance လို.သုံးပါတယ်။ ဥပမာ အောက်က Java program ဆိုပါစို.

class Base
{
int baseData;
}

class Child extends Base
{
int childData;
}

Child object တိုင်းမှာ base class ကရတဲ့ baseData နဲ. child class ရဲ. childData ဆိုပြီး property 2 ခုရမှာပါ။ Child object တခုဆောက်တိုင်း သီးခြား baseData တခုစီရနေမှာပါ။ Parent က property တွေကို child object အတွက် seperate copy ပေးထားတဲ့သဘောပါ။ Inheritance with copy semantic လို.ပြောလို.ရပါတယ်။ ဒါဟာ classical inheritance ပါ။

Prototypical Inheritance
JavaScript မှာပေးထားတဲ့ inheritance model က prorotypical inheritance ပါ။

function Base()
{
this.baseData = [];
}
function Child()
{
this.childData = "childdata";
}
Child.prototype = new Base();//set up inheritance

var c1 = new Child();
();
var c2 = new Child();
();
c1.baseData.push(100);
.baseData.push(100);
console.log(.log(c2.baseData);

အေပၚက program မွာ Child.prototype = new Base(); ဆိုတဲ့ statement သုံးပြီး prototype chain ကို setup လုပ်ပါတယ် meaning ကတော့ child ရဲ. parent သည် new Base() (Base object) တခုဖြစ်ပါတယ် ဆိုတာပါပဲ။ Classical inheritance မှာ parent သည် class တခုဖြစ်ပေမဲ့ prototypcial inheritance မှာတော့ parent သည် object တခုဖြစ်ပါတယ်။ အဲ့ဒီအပြင် child object c1 နဲ. c2 ဟာ parent object တခုတည်းကို share လုပ်သုံးရပါတယ်။ အောက်ဆုံးအကြောင်းမှာထုတ်ထားတဲ့ c2.baseData ဆိုရင် [100] လို.တွေ.ရမှာပါ။ တကယ် change လိုက်တာက c1 ရဲ. baseData ကို ပြောင်းလိုက်တာပါ။ ဒါပေမဲ့ c1 ရော c2 ရောက same parent object တခုတည်းကို share သုံးရတဲ့အတွက် c2.baseData ဆိုရင်လဲ [100] လို.ထွက်ပါတယ်။ အောက်က statement လေးကို တချက်ကြည့်ပါ

c1.baseData.push(100);

ဒါက c1 ဟာ parent ရဲ. baseData ကို read access လုပ်တာပါ။ JavaScript ရဲ. inheritance model ကနည်းနည်းရှုပ်ပါတယ်။

တကယ်လို.များ

c1.baseData = [200]; လို.ရေးလိုက်ရင် c1 မှာ သူ.ရဲ.ကိုယ်ပိုင် baseData ဆိုတဲ့ attribute ကို JS ကထဲ့ပေးတော့မှာပါ။ Attribute တွေကို JS မှာရှာတဲ့ပုံစံက read ဆိုရင် current object ကနေ ရှာပါတယ်။ နောက်မတွေ.ရင် သူ. prototype chain ကိုလိုက်ရှာပါတယ်။ တကယ်လို. write သာလုပ်မယ်ဆိုရင် parent မှာရှိနေလဲ သူ.current object မှာမရှိရင် attribute အသစ်အနေနဲ.ထဲ့ပေးမှာပါ။ ဒါကိုသတိထားစေချင်ပါတယ်။ Prototypical inheritance သည် share semantic ဖြစ်ပါတယ်။ Parent object ထဲကို attribute တွေ ထပ်ထဲ့တာ နှုတ်တာ အားလုံးသည် child အားလုံးမှာ effect ဖြစ်ပါတယ်။

Dynamic Inheritance
Prototypical inheritance ပေးတဲ့ language တွေမှာ parent object ကို dynamically ပြောင်းလို.ရပါတယ်။ ဒါကို dynamic inheritance လို.ခေါ်ပါတယ်။ state အပြောင်းအလဲပေါ်မူတည်ပြီး လုပ်ရတဲ့ code တွေမှာဆို Dynamic Inheritance ဟာ အသုံးဝင်ပါတယ်။

ဆက်ရန် :3

Gentle Introduction to Object Oriented Programming Part 1

ခုလောလောဆယ် Industry မှာ အသုံးအများဆုံး programming language paradigm အရဆိုရင်တော့ Object Oriented Programming က popular အဖြစ်ဆုံးလို.ပြောရမှာပါ။ အသုံးများတဲ့ OO Language တွေကတော့ Java, C #, JavaScript, PHP, Ruby , Python တို.ပါပဲ၊ Language တခုကိုလေ့လာတဲ့အခါမှာ element ၃ ခုကိုလေ့လာရပါတယ်။ Syntax, Semantic နဲ. Pragmatic တို.ဖြစ်ပါတယ်။ Syntax ကတော့ရှင်းပါတယ် language basic component တွေကို ဘယ်လိုရေးရတာလဲဆိုတဲ့ Grammar ပါ။ ဥပမာ for loop ပတ်ရင်ဘယ်လိုရေးရသလဲပေါ့။ Semantic ကတော့ for loop ရေးထားရင် for loop ကဘယ်လိုအလုပ်လုပ်မလဲဆိုတဲ့ တိကျတဲ့အဓိပ္ပာယ်ကို ဆိုချင်တာပါ။

ဥပမာ for initialization ရှိရင် run မယ်။နောက် for conditional ရှိရင်စစ်မယ် result က true ဆိုရင် for body ကို execute မယ်။ ပြီးရင် for increment ရှိခဲ့ရင် သူ.ကို run မယ် နောက် loop အစကိုပြန်တက်မယ် condition ပြန်စစ်မယ် ပေါ့။ ဒါတွေကို semantic လို.ခေါ်ရမှာပါ။ Programming သင်တယ်လို.ပြောလိုက်ရင် syntax ကိုပဲသင်ကြတာကို တွေ.ရပါတယ်။ language 2 ခုက syntax အရ ဆင်နိုင်ပါတယ် ဒါပေမဲ့ semantic အရ မတူနိုင်ပါဘူး ဥပမာ for loop ဆိုပါစို. C,C++,Java,C #,JavaScript တို.မှာ syntax အရသိပ်မကွာပါဘူး ဒါပေမဲ့ semantic အရ မတူနိုင်ပါဘူး။ ဥပမာ C/C++/JavaScript မှာ conditinal part ဟာ boolean မဟုတ်တဲ့ integer တခုခု (JS မှာဆို Object type ပါဖြစ်နိုင်ပါတယ်) ဖြစ်ခွင့်ရှိပေမဲ့ Java,C # မှာဆိုရင် boolean type ကိုဖြစ်ရမှာပါ။ နောက်တခုက for initialization မှာ variable ကြေငြာ ခဲ့ရင် C,C++,Java,C # မှာဆိုရင် for loop အတွင်းမှာပဲ variable scope ကရှိပေမဲ့ JavaScript မှာဆို the whole function တခုလုံးလို.ပြောရမှာပါ။ ဒါဟာ semantic အရ မတူကြောင်းကိုပြောတာပါ။

နောက်တခုက Pragmatic ပါ။ သူကတော့ language တခုရဲ. construct တွေကို လက်တွေ.ကျကျဘယ်လိုသုံးရမလဲဆိုတာပါ။ Programming language တခုကပေးထားတဲ့ feature တွေ language construct တွေကို သင့်တော်မှန်ကန်စွာ အသုံးချနိုင်မှု.ပါ။ ဘာကိုဆိုချင်သလဲဆိုတော့ OO paradigm ကို support ပေးတဲ့ language မှာ OO program တွေကို ဘယ်လိုရေးရသလဲ ။ ဥပမာ ဘယ်အချိန်မှာ inheritance ကိုသုံးလဲ ရိုးရိုး class ကိုသုံးရမှာလား abstract class ကိုသုံးရမှာလား abstract class နဲ. interface usage ဘယ်လိုကွာလဲ ဘယ်နေရာဘယ်သူ.ကိုသုံးရမှာ correct usage က ဘာတွေလဲ ဒါတွေကို ဆိုချင်တာပါ။ Pragmatic ကိုအဆင့်ထပ်မြှင့်ရင်တော့ design pattern တွေ ,principle တွေ ပါ ပါလာမှာပါ။ Programmer တယောက်အနေနဲ. Language construct တွေ paradigm နဲ.ပတ်သတ်တဲ့ concept တွေကိုသိဖို.လိုပါတယ်။ Java နဲ.ရေးနေပေမဲ့ C မှာရေးသလို function တွေနဲ.ပတ်လည်ရေးနေတယ်ဆိုရင် မဟုတ်တော့ပါဘူး။

Evolution to OOP
Modern high level Programming language တွေမပေါ်ခင်က machine language သို.မဟုတ် assembly language ကိုသုံးရပါတယ်။ Assembly ကိုသုံးရတာဟာ machine language ကို symbolic code အစားထိုးသုံးရတာနဲ.ဘာမှမကွာပါဘူး။ သိပ်မဟန်ပါဘူး ။ဒါကြောင့် high level language တွေထုတ်ပါတယ်။ အစောပိုင်းက data structure နဲ. algorithm တွေရေးလို.အဆင်ပြေအောင် ထုတ်ထားတဲ့ Procedural Language(Fortan, Algo, C) တွေပေါ်လာပါတယ်။ Procedural language တွေရဲ.အဓိက concept ကတော့ fuction တွေခွဲရေးမယ် ။ function တွေကို reusable ဖြစ်အောင်လုပ်မယ်။ ဒီလိုနည်းနဲ.သွားပါတယ်။ နောက်ကျတော့ data abstraction ကိုထဲ့လာပါတယ်။

Data Abstraction
Data Abstraction ဆိုတာ custom data type တွေ create လုပ်ခွင့်ပေးထားတာကိုပြောတာပါ။ ဥပမာ Stack, LinkedList ဆိုတာမျိုးကို data type တခုအနေနဲ.ကိုယ်ပိုင် ဖန်တီးလို.ရမယ်။ ပြန်သုံးလို.ရမယ် ဒါကို data abstraction လို.ပြောလို.ရပါတယ်။ ဥပမာ C မှာ ဆို struct, enum, class ဆိုတာ data abstraction တွေပေးထားတာပါ။ Primitive type တွေကနေ custom data type ဖန်တီးလို.ရမယ် အဲ့ data type ကို maniuplate လုပ်ဖို. function တွေ create လုပ်လို.ရမယ်ဆိုရင် အဲ့ဒီ language ကို data abstraction ပေးတယ်လို.ပြောရမှာပါ။

Beginning of OOP
Data abstraction ကြောင့် custom data type တွေ တော့ဖန်တီးလို.ရပါပြီ။ ဒါပေမဲ့ ပြဿ နာ တခုက သူ.ကိုပြင်မယ်ဆိုရင် ဆိုပါစို. existing ADT(Abstract Data Type) တခုကိုပြင်မယ်ဆိုရင် သူ. source code ကိုပြင်ရမှာပါ။ ဒါကို destructive modification လို.ခေါ်ပါတယ်။ အဲ့ဒါက အန္တရာယ်များပါတယ် ဘာလို.လဲဆိုတော့ project တခုမှာ ADT တခုကို reference လုပ်ပြီးသုံးထားတဲ့ code တွေ အများကြီးရှိနိုင်လို.ပါ။ ADT ရဲ. source code ကိုမထိပဲပြင်နိုင်တဲ့ နည်းကတော့ OOP သုံးပြီး inheritance နဲ. functionality အသစ်ကို ထပ်ထဲ့တာ existing method ကို modify လုပ်တာပါပဲ။ ဒါဆို ရှိပြီးသား code ကို မထိပဲနဲ. ပြင်လို.ရပါပြီ။ Software ဆိုတာ ရေးပြီးတာနဲ.ပြီးတာမဟုတ်ပဲ အမြဲ ပြောင်းလဲနေနိုင်ပါတယ် OOP ရဲ. feature တွေက ဒါတွေကို handle လုပ်နိုင်ပါလိမ့်မယ်။

Data Abstraction versus OOP
Data abstraction က custom data type တွေ တည်ဆောက်လို.ရမယ်။ OOP ဖြစ်ဖို.ကတော့ အောက်ပါ သုံးချက်ကိုမဖြစ်မနေပေးရပါတယ်။ အဲ့ဒါတွေကတော့
Encapsulation
Inheritance
Polymorphism

တို.ပါပဲ။ Object တော့ပေးဆောက်တယ် feature သုံးခုလုံးမပါဘူဆိုရင် Object based language လို.ပဲခေါ်မှာပါ ဥပမာ Visual Basic( VB.NET ကတော့ OOP Feature သုံးခုလုံးပေးထားပါတယ်). OO language ရဲ.အားသာချက်ထဲက တခုက တော့ conceptual modelling ပါပဲ၊ အရင်က software development ကို function တွေ algorithm တွေနဲ.စဉ်းစားမဲ့အစား real world မှာရှိတဲ့အတိုင်း object တွေအနေနဲ. စဉ်းစားရတဲ့ ပိုလွယ်ကူပါတယ်။ real world မှာရှိတဲ့ အတိုင်း classification (by mean of class), taxonomy (by mean of inheritance), specialization (by mean of polymorphism) အတိုင်း model လုပ်လို.ရသွားပါတယ်။

Pure and Impure OO Language
Programming language တခုဟာ Object ကလွဲပြီး တခြား construct တွေပေးမထားဘူးဆိုရင် သု.ကို pure Object Oriented Language လို.သုံးပါတယ်။ ဥပမာ Smalltalk မှာဆို loop ဆိုတာမျိုး မရှိပဲ loop ဆိုတာကို method တစ်ခုအနေနဲ.ယူဆပါတယ်။ integer လိုကောင်မျိုးတွေကအစ object တွေပါ ဒါကြောင့် pure OO language လို.သုံးပါတယ်။ ဘာကောင်းလဲဆိုတော့ program တစ်ခုလုံးကို OO နည်းနဲ.ပဲစဉ်းစားရအောင် လုပ်ထားတာပါ။ C++, Java,C #,JS တို.ကတော့ impure object oriented language လို.ပြောရမှာပါ။ သူတို.မှာ primitive data type တွေပါပြီး control structure (for/switch etc) တွေပါလို.ပါ။

Encapsulation
Procedural language တွေမှာ data ကိုဘုံထားပြီး function တွေကနေဝိုင်းသုံးကြပါတယ်။ Project size ကြီးလာတာနဲ.အမျှ အဲ့ဒီ ဘုံသုံးထားတဲ့ variable(global variable) တွေကို ဘယ် module, ဘယ် function ကသုံးထားတယ်ဆိုတာ လိုက်ကြည့်ဖု.ိတော်တော်ခက်သွားပါပြီ။ PHP မှာဆို global variable သုံးပြီး page အများကြီး ဝိုင်းသုံးတာမျိုးပါ။ နောက်ပြီး ကိစ္စရှိလို. အဲ့ဒီ global variable ကိုပြင်မယ်ဆိုရင် သူ.ကို သုံးထားတဲ့ module တွေ function တွေကို ပါလိုက်ပြင်ရမှာပါ။ တခုခုကိုပြင်ရင် တခြား အပိုင်းတွေပါ ထိခိုက်ကုန်ပါတယ်။ ဒါကြောင့် OO language မှာ အဲ့တာကိုမဖြစ်အောင် ကာကြပါတယ်။ Program တွေကို modular ဖြစ်အောင်ရေးဖို.ကြံဆကြပါတယ်။ Modular ဖြစ်တယ်ဆိုတာ program module, function, contruct တခုဟာ သူ.ဟာသူနဲ.ရပ်တည်နိုင်ရပါမယ်။ သူများ function တွေကို အများကြီးသုံးနေရတာ dependency များနေတာ မဖြစ်ရပါဘူး။ Modular ဖြစ်မှ dependency နည်းမှပဲ ပြင်ရတာ လွယ်ကူမှာဖြစ်ပါတယ်။ ဒါကြောင့် global variable အစား ကို. data ကိုပဲသုံးမယ် သူများက လာသုံးမရအောင် access ကို restrict လုပ်ထားမယ် သူ. data ကို သူ. method တွေကပဲသုံးမယ် တခြားသော module တွေက ဒီ module ကို သုံးချင်ရင် module ကပေးထားတဲ့ public interface(publicly accessible method) တွေ ကနေ သုံး။ ဒါဆိုရင် တခြား module တွေဟာ သူများရဲ. data ကိုသွားထိလို.မရတဲ့အတွက် သီးသန်.ဆန်သွားတဲ့အတွက် modularity ပိုကောင်းပါတယ်။ module တခုကိုပြင်မယ်ဆိုရင် public interface(public interface ကပဲသူများ module နဲ. dependence ဖြစ်ပါတယ်) ကိုမပြင်မချင်း လွတ်လွတ်လပ်လပ်ပြင်နိုင်မယ်။ ဒါကို encapsulation လို.သုံးပါတယ်။ Encapsulation ရဲ.အနှစ်သာရက ကို. data ကိုသူများက accidentally destroy မဖြစ်အောင် dependency မရှိအောင် ထားရတာပါ။ Encapsulation ကို data hidiing နဲ.တွဲသုံးပါတယ်။ Encapsulation နဲ. data hiding ဟာ တူသလိုလိုနဲ. ကွဲပါတယ် data hiding က ကို.data ကိုပြင်ပက လာသုံးလို.မရအောင်ကာထားတာမျိုးပါ။ Encapsulation ကတော့ data ကို ကို. function တွေနဲ. modularity ရအောင် ချိတ်သုံးတာကို ဆိုချင်တာပါ။ Java, C #, C++ မှာဆို private accessifier တွေသုံးပြီး encapsulation ရအောင်လုပ်ကြပါတယ်။ Member variable ကို Private ထားပြီး getter ,setter function တွေနဲ.သုံးကြပါတယ်။ အဲ့လိုသုံးတိုင်း encapsulation မရနိုင်ပါဘူး ။ အောက်က Java Program ကိုကြည့်ပါ။

class WrongEncapsulation
{
private CreditCard card;
public void setCard(CreditCard c){...}
public CreditCard getCard()
{
return card;
}
}
ဒီ Program မှာ card က private ပါ reference type ပါ။ သူ.ကို တိုက်ရိုက်ယူသုံးလို.မရပေမဲ့ getCard ကနေ ယူသုံးလို.ရ့ပါတယ်။ဒါဆို တနည်းအားများ card ကို တိုက်ရိုက်ယူသုံးနိုင်တာနဲ.အတူတူပါပဲ။ Java က reference model ကိုသုံးတဲ့အတွက် အပြင်ကနေ card ကို ပြင်လို.ရမှာပါ။ဒါဆို encapsulated ဖြစ်တယ်လို.မပြောနိုင်တော့ပါဘူး။ JavaScript လို language မျိုးကျတော့ access modifier မပါပါဘူး ဒါပေမဲ့ full encapsulation ကိုလုပ်လို.ရပါတယ်။ Closure သုံးပြီး encapsulate လုပ်နိုင်ပါတယ်။


function getObject() {
var data;

function dataGetter() {
return data;
}

function dataSetter(d)
{
data = d;
}
return {
setData : dataSetter,
getData : dataGetter
};
}
var obj = getObject();
obj.setData(100);
console.log(obj.getData());


အပေါ်မှာပြထားတဲ့ JavaScript code မှာ encapsulation ကိုပြထားပါတယ်။ getObject function ထဲမှာရှိတဲ့ data ဟာ encapsulated လုပ်ခံထားရတာပါ။ သူ.ကိုအပြင်ကနေ တိုက်ရိုက်ယူသုံးလို.မရပါဘူး။ ဘာလို.လဲဆိုတော့ local varaible မို.လို.ပါ။ getObject function အောက်ဆုံးမှာ object တခု return ပြန်ထားပါတယ် အဲ့မှာ setData, getData ကို getObject function ထဲက dataSetter,dataGetter ကိုပေးထားပါတယ်။ dataSetter,နဲ. dataGetter ဟာ inner function တွေဖြစ်တဲ့အတွက် data ကို enclosing scope က data ကိုယူသုံးလို.ရပါတယ် ။ သူတို.ကိုတော့အပြင်ကနေ တိုက်ရိုက်သုံးလို.မရပဲ setData နဲ. getData ကတဆင့်သုံးရမှာပါ။ JS မှာဒီနည်းနဲ. Encapsulation ထိန်းလို.ရပါတယ်။ Encapsulation ဆိုတာ class level ထိန်းမှမဟုတ်ပါဘူး package , module တွေဟာလဲ ပြင်ပ ကကောင်တွေတိုက်ရိုက်သုံးလို.မရအောင် ထိန်းပေးထားတဲ့ encapsulation construct တွေပါပဲ။ Encapsulation နဲ. ပတ်သတ်တဲ့ OO Principle တခုရှိပါတယ် အဲ့ဒါကတော့ Program to interface, not to implementation ပါ။ Program ရေးတဲ့အခါမှာ module တွေ class တွေဟာ သူများရဲ. implementation detail ကိုမသိသင့် မထိသင့်သလို. ကို.ဟာကိုလဲ expose မလုပ်သင့်ပါဘူး။ အပြင်ကသုံးမဲ့ ကိုနဲ.တကယ် interact ပေးလုပ်မဲ့ကောင်တွေကိုပဲ public interface အနေနဲ.ထားပေးရမယ်ဆိုလိုတာပါ။ ဒါမှ maintenance ကောင်းမှာပါ။Encapsulation နဲ.ပတ်သတ်တဲ့ တခြား OO principle တခုကတော့

Open Close Principle ပါပဲ။
A module should be open for extension but closed for modification.
Module တွေ classes တွေဟာ သူတို.ကို accidentally modified မလုပ်နိုင်အောင်ထားသင့်ပြီးတော့ extend လုပ်နိုင်အောင်တော့ ထားပေးရမယ်ဆိုတာပါ။ Encapsulation ရဲ. central theme ကိုက close for modification ပါပဲ။

Apache2 Ubuntu Default Page: It works This is the default welcome page used to test the correct operation of the Apache2 server after installation on Ubuntu systems. It is based on the equivalent page on Debian, from which the Ubuntu Apache packaging is derived. If you can read this page, it means that the Apache HTTP server installed a...

How does JavaEE work.
Java က စထုတ်တုန်းက SE ပဲရတယ် standard edition ပေါ့ ဆိုချင်တာက desktop application ပဲရေးဖို.လုပ်ထားတာ။ နောက်ကျတော့ JavaEE ထုတ်လာတယ် အဲ့တော့ enterprise application လွယ်လွယ်ပြောရရင် server side web application ရေးလို.ရလာတယ်။

PHP လိုကောင်မျိုးကျတော့ စထုတ်ကတည်းက server side scripting language အနေနဲ.ထုတ်တာ။ Programming language တွေက ဘယ်လိုလုပ်ပြီး web server တွေနဲ.ချိတ်ဆက်လုပ်တယ် ဒါမှမဟုတ် ဘယ်လိုလုပ် web application ပေးရေးတယ်ဆိုတာကိုနားလည်ဖို. HTTP protocol ရယ် Web server အကြောင်းရယ် နားလည်ဖို.လိုတယ်။
အရင်က အဲ့ဒီအကြောင်းဒီမှာရေးဖူးတယ်

https://web.facebook.com/thet.khine.587/posts/10207213385452495
PHP လို server side scripting language တွေကျတော့ web server နဲ.တန်းချိတ်ပြီးအလုပ်လုပ်တယ်။ Apache လို web server မျိုးပေါ့။ Web server တွေသည် external application program တွေနဲ.ချိတ်ဆက်လုပ်ဖို. interface ပေးထားတယ်။ CGI လို.ခေါ်ကြတယ်။ Common Gateway interface ပေါ့။ Request တခုလာမယ် အဲ့ကနေ web server က တခြား external program ကိုခေါ်မယ် နောက်လိုအပ်တဲ့ data တွေလှမ်းပေးမယ်။ နောက် external program (eg PHP) လိုကောင်က ထွက်လာတဲ့ output တွေကို web client ကိုပြန်ပေးမယ်ပေါ့။ CGI တွေက request တခုလာ process တခုလုပ်လေးလာတော့ နောက်ပိုင်း fast CGI သုံးလာတယ်။

ထားတော့ Java ဘက်ကျတော့ အဲ့လိုမဟုတ်ဘူး web server နဲ.တိုက်ရိုက်မချိတ်ဘူး အဲ့တော့ ဘာလုပ်ရသလဲဆိုတော့ ကိုယ်ပိုင် HTTP server(web server) ဆောက်ရတယ်။ ဉပမာ Java နဲ. Web server ရေးလိုက်တယ်(JavaSE က network programming သုံးပြီး socket program တွေနဲ.လုပ်လိုက်တယ်) ဒါဆို web content တွေ serve လုပ်လို.ရပြီ။ အဲ့ layer အပေါ်ကိုမှ server side program တွေ ရေးလို.ရအောင် servlet ဆိုတဲ့ class တွေထပ်ထဲ့လိုက်တယ်။

Servlet သည် Web request ကိုလက်ခံမယ် output ကိုပြန်ပေးမယ် အဲ့တာလေးပဲ basic flow က ။ ခုနက servlet API ကို support ပေးထားတဲ့ container တွေကို servlet container လို.ခေါ်တယ် ဥပမာ tomcat ပေါ့။
အဲ့တော့ tomcat ထဲမှာဘာပါလဲ ဆိုရင် အဓိက web server (Coyote http connector လို.သုံးတယ်) နောက် servlet ကို support လုပ်ဖို. servlet container( Catalina လို.ခေါ်တယ်) ပါတယ်။

နောက် ခုနက Servlet သည် Java code တွေချည်းရေးရတာ ဆိုချင်တာက html view layout တွေရေးမယ်ဆိုရင် IO command တွေကနေ string နဲ.ရိုက်ထုတ်ရတာ။ အဲ့တော့ view အပိုင်းအဆင်မပြေဘူး အဲ့တာကိုရှင်းဖို.အတွက် JSP ထုတ်လိုက်တယ်( JavaServer Page ) ပေါ့ HTML , Java code တခါတည်းပေါင်းရေးလို.ရသွားတယ်။ JSP ဆိုတာလဲ တကယ်တမ်းက servlet ပါပဲ JSP page ကို compile လုပ်ရင် servlet ပြန်ရတယ်။

ခုနက JSP ကနေ servlet ထုတ်ပေးတဲ့ကောင်ကို JSP Engine လို.ခေါ်တယ်။ Tomcat မှာဆို Jasper engine ပေါ့။ နောက် JSF လို MVC ကောင်တွေထွက်လာတယ် သူတို.လဲ အောက်ဆုံးမှာ Servlet ကိုသုံးရတာပါပဲ။
JavaEE component တွေ technologies တွေ မအောင်မြင်တာကြောင့် third party framework တွေ Spring လိုကောင်တွေထုတ်လာတယ်။ Spring ကျတော့ အဓိက DI support ပေးတယ်။ နောက်ကွယ်မှာ အဓိက server side သုံးတာကတော့ servlet based ကိုပဲသုံးတာ။ Front Contoller pattern ကိုသုံးထားတဲ့ servlet က request တွေကိုအကုန်ဖမ်းထိန်းပြီး မှ နောက် ဆိုင်ရာ controller တွေဆီကိုပို.ပေးတာ။ DispatcherServlet လို.ခေါ်တယ်။

နောက်ပိုင်း Node.js က rest API framework တွေခေတ်စားလာတော့ Java ဘက်မှာခုနက container တွေမလိုပဲ framework ထဲမှာတင် web server ပါလာအောင် content handling ထဲ့ပေးထားတဲ့ micro framework တွေပေါ်လာတယ် eg. spark.

Why use token authentication

Authentication ဆိုတာက system တခုကိုသုံးခွင့်ရှိတဲ့ user ဟုတ်မဟုတ်(identity) ကိုစစ်တာ ဥပမာ ကျောင်းထဲဝင်ဖို့
ကျောင်းသား ဒါမှမဟုတ် ဆရာ ဒါမှမဟုတ် ကျောင်းမှာအလုပ်လုပ်နေတဲ့သူတွေပဲဝင်လို့ရမယ်။ ကျောင်းကို system လို့သတ်မှတ်ရင်
ခုနက ကျောင်းသား ဆရာ စတာတွေက valid user ပဲ။ အပြင်လူဝင်လို့မရဘူး။ ဥပမာ facebook သုံးရင် facebook user ဖြစ်မှ
သုံးလို့ရမယ်။

Authorization

Authorization ဆိုတာကျတော့ user က valid user ဖြစ်ပြီ(already authenticated) ဒါပေမဲ့ resource တခုခုကို
access လုပ်ဖို့ right ရှိသလားဆိုတာစစ်တာ၊ ဥပမာကျောင်းထဲ ကျောင်းသားကဝင်လို့ရပေမဲ့ ကျောင်းအုပ်ကြီး ဗီဒိုတော့ဖွင့်ခွင့်ရှိမှာမဟုတ်ဘူး။
အဲ့တာက Authorization, ဥပမာ user level role ပဲရှိတဲ့သူက admin level role ရှိတဲ့ page, function စတာတွေ
သုံးလို့မရဘူး။

Token based authentication ဆိုတာ Web, Mobile, Server to server(microservices) စတာတွေမှာ
token တခုကိုသုံးပီးတော့ authenticated လုပ်တာကိုပြောတာ။ Token ဆိုတာ ကတော့ များသောအားဖြင့် user identity ဒါမှမဟုတ် grant ကို hash ယူထားတာပါပဲ။
Physical token (key card လိုကောင်တွေ) တွေရှိသလို software token တွေရှိပါတယ်။ software token ဘက်မှာဆို OAuth, JWT စတာမျိုးတွေရှိကြပါတယ်။

JWT ကဒီမှာရေးထားဖူးပါတယ်။
https://www.facebook.com/thet.khine.587/posts/pfbid02NLUMj5Vi8cu5gFXNv1CFHg2SNuXrrXtuyRkqU6tggA7hQKCYfUdcRKG87rJWLCvWl

Token based authentication flow က ဒီလိုသွားတယ် အကြမ်းဖျင်းပေါ့

user က login ဝင်ဖို့ username,password နဲ့ပေးလိုက်တယ် server ဘက်က username password မှန်ရင် token
ပြန်ပေးလိုက်တယ်။ အဲ့ token ကို နောက် API call တွေဖို့ header ထဲမှာထဲ့ပေးလိုက်တာ။ဒါဆို server က token
ကိုစစ်ပြီး valid token ဆိုရင် authenticated ဖြစ်ပြီဆိုပြီးသတ်မှတ်လိုက်တာ။

များသောအားဖြင့် access token, refresh token ဆိုပြီးသုံးကြတယ်။ Access token က သက်တမ်းတိုတယ်။
ဘာလို့ဆိုတော့ token ကိုရသွားရင်ပေါက်သွားမှာစိုးလို့၊ အဲ့တော့ acess token expiry ဖြစ်သွားရင် refresh token
ကိုသုံးပြီး access token ပြန်ထုတ်တယ်။ refresh token ကျတော့ expire time ကိုကြာကြာထားလေ့ရှိတယ်။

Web application တွေဆိုရင် session based authentication ကိုလဲသုံးလို့ရတယ်။ User က login ဝင်မယ်။
Credential မှန်ရင် unique session ID ထုတ်ပေးလိုက်မယ်။ Session ID ကိုဘယ်လိုထုတ်သလဲဆိုတော့ timestamp,
user_id, random number, hash စတာတွေသုံးပြီးထုတ်တယ်။ Language တခုနဲ့တခုတော့မတူဘူး Guess လုပ်ရခက်အောင်
unique ဖြစ်တဲ့ hash ပဲ။ ပြဿနာက သူ့ကို file system ဖြစ်ဖြစ် (PHP မှာဆို file မှာသိမ်းတယ်) DB မှာဖြစ်ဖြစ်သိမ်းရတယ်။
အဲ့တော့ scalable မဖြစ်ဘူး။ဥပမာ ဒီ session က valid ဖြစ်လား စစ်ဖို့ File read, DB Read လုပ်နေတာ မျိုးသည် IO ပါတယ်။
JWT လို token မျိုးကျတော့ in memory မှာတင် hash တွက်လို့ရတယ် ပိုမြန်တယ်။
နောက် session တွေသည် ဆိုင်ရာ web server နဲ့ tie ဖြစ်တယ်။ တကယ်လို့ ကိုယ်က scalability ရဖို့ load balancer
နောက်မှာ web server ၂ ခုသုံးရမယ်ဆိုရင် web server1 နဲ့ session ID ထုတ်ထားတဲ့ request သည် web server 1 ဆီကိုပဲသွားရတယ်
အဲ့တော့ load balancing မှာအဆင်မပြေဘူး။ sticky session လို့ခေါ်တယ်။
Token based ကျတော့အဲ့လိုမဖြစ်ဘူး ကြိုက်တဲ့ကောင်သွား microservices architecture မှာဆိုအိုကေတယ်။

များသောအားဖြင့် web session တွေကို cookie မှာသိမ်းကြတယ်အဲ့တော့ CRSF attack ဖြစ်နိုင်တယ်။

Token တွေကို server ဘက်ကနေ revoke လုပ်နိုင်တယ်။အဲ့အခါကျတော့ tigher control ဖြစ်တယ်။

Federate authentication

Authentication system တခုထဲကိုသုံးပြီးတော့ multiple system တွေကို access ပေးတာ၊ ဥပမာ Facebok, Google
သုံးပြီးတော့ medium တို့လိုကောင်တွေကို register/login ဝင်လို့ရတယ် ဒါမျိုးကို Federate authentication လို့ခေါ်တယ်။
SSO (Single Sign On )လို့လဲသုံးကြသေးတယ်။

ခုနက session id လိုကောင်မျိုးက ဆိုင်ရာ system DB, file system မှာသိမ်းတဲ့အတွက် ဥပမာ app1 က db ကို app2 ကို
ပေးသုံးမှ login ဝင်လို့ရမဲ့ပုံစံဖြစ်တယ်။ Token ကျတော့ သိမ်းထားတာမရှိတဲ့အတွက် Federate authentication
ပိုအဆင်ပြေတယ်။