Algorithm Interview Preparation

ဒီရက်ပိုင်း Algorithm Interview Question လေးတွေလိုက်လုပ်ဖြစ်တယ်။ ကိုယ့်ကိုယ်ကိုလည်းလုပ်ဖို့ဖိအားဖြစ်အောင်သုံးရက်တစ်ပုဒ်လောက်တင်ဖို့ကြိုးစားပြီးတင်ပေးပါ့မယ်။ Algorithm Question တွေမဖြေခင် Big O Notation ဆိုတာဘာလဲ ဆိုပြီးကျွန်တော်ရေးထားတာကိုအရင်ဖတ်ပေးပါ။

Algorithm Interview တွေကိုဖြေတဲ့အခါမှာ Data Structure တွေသိထားဖို့ကလည်းအရေးကြီးပါတယ်။ ဒါမှ Problem ပေါ်မှာမူတည်ပြီးတော့ဘယ် Data Structure ကိုသုံးရင်ပိုမြန်တယ်၊ ပိုပြီးအကျိုးသတ်ရောက်မှုရှိတယ်ဆိုတာကို ဆုံးဖြတ်ရွေးချယ်လို့ရမှာဖြစ်တော့ Data Structure တွေကိုအရင် ဒီမှာ Study လုပ်ပါ

Array/String

  • Valid Anagram
  • Two Number Sum
  • Valid Palindrome
  • Implement strstr()
  • Reverse Words in a String Reverse Words in a String II
  • String to Integer
  • Valid Number
  • Longest Substring Without Repeating Characters
  • Longest Substring with At Most Two Distinct Characters

ကြော်ငြာ – Developer/Designer အလုပ်တွေရှာနေတယ်ဆို MyanmarDevJobs.com မှာရှာနိုင်ပါတယ်။

Business Soft Skills

ကျွန်တော်တို့ Developer တွေမှာ အားနည်းချက်က Soft Skills ပါဘဲ။ YGNCode မှာ အဓိကအားဖြင့် Technical အကြောင်းရေးမှာဖြစ်တဲ့အတွက် Soft Skills ကိုဘယ်ကနေလေ့လာလို့ရလဲဆိုတာရှာကြည့်ပြီးတော့ အားလုံးအတွက်အသုံးအဝင်ဆုံးဖြစ်နိုင်တဲ့ကောင်ကိုပြန်လည်ဝေမျှလိုက်ပါတယ်။ အလုပ်ရတဲ့အခါမှာ လစာညှိတာကမစ Team နှင့်အလုပ်လုပ်တာအဆုံး… Stress Management ဘယ်လိုလုပ်ရမလဲဆိုတာတွေပါ discuss လုပ်ရှင်းပြထားတဲ့ Crash Course YouTube PlayList ကိုပြန်လည်ဝေမျှလိုက်ပါတယ်။

Crash Course Business – Soft Skills

nanOS/ မိုက်ခရို ဆားဗစ် ပုံစံများအပေါ်သုံးသပ်ခြင်း

ယခု ရေးသားထားသော စာစု သည် မူရင်း တွင် အင်္ဂလိပ်ဘာသာဖြင့် ရေးသားထားပြီ ယခု မြန်မာဘာသာ ပြန်ဆို တင်ဆက်ခြင်းဖြစ်ပါသည် ။ မူရင်းကို ကြည့် ရှု လိုပါက တွင် ကြည့်ပါ။

အတွေး

ယခု နောက်ပိုင်း Cloud Service တွေ ဒီဇိုင်းလုပ်ရာမှာ အသုံးပြုတဲ့ နည်းပညာတွေ အလေ့အကျင့် တွေကို သုံးသပ်ရင်း၊ သုံးဆွဲရင်း စဉ်းစားမိတာ လေးပေါ့။ မိုက်ခရို ဆိုပြီး လူပြောများ သော်လည်း သုံးဆွဲရန် ပြောင်းလဲရန် ခက်ခဲတဲ့ Methodology ကိုု သုံးရင်း Security ပိုင်း လျေ့ာသွားတာမျိုး မရှိပဲ Performance ကို မြန်အောင် ဘယ်လိုလုပ်ရမလဲပေါ့။

Product Makerတွေ မန်နေဂျာတွေကတော့ မိုက်ခရို က ခက်တယ် Resource Consuming ဖြစ်တယ် အရမ်း ထိန်းချုပ်ရတာ လက်ဝင်တယ် ထင်ကြမယ်။ ဒါပေမယ့် အဲ့လိုခက်လို့ကို ပဲ ကိုယ့်ဆားဗစ်ကို နှစ်ရှည်လများ သွားမယ်ရည်ရွယ်ထားရင် အစကတည်း ကို က Design မှာ လုပ်သင့် တယ် လို့မြင်တယ်။

အကယ်လို့ကြားထဲက အပိုစာသားတွေရှည် တယ်ထင်ခဲ့ရင် စာစုရဲ့မူရင်း Main Title ဖြစ်တဲ့ Section:4 Baremetal ကိုုကျော်ဖတ်နိုင်ပါတယ်။

MICRO IS GOOD

စစခြင်း တော့ Monolithic Stack တွေဖြစ်တဲ့ ROR တို့ Laravel တို့နဲ့ Logic တွေ API တွေ ရေးလေ့ရှိခဲ့ကြပါတယ်။ Framework တွေက Powerful ဖြစ်သလို Code လည်းသန့်ပြီး Feature တွေပစ်ထည့်ရတာလွယ်ပါတယ်။ Framework Specific Developer တစ်ယောက် နှစ်ယောက် လောက်နဲ့ Service တစ်ခုလုံးကို Implement လုပ်လို့ရပါတယ်။ Micro သွားစရာမရှိဘူးလို့မြင် ကောင်းမြင်ပါလိမ့်မယ်။

အဲသလိုနဲ့ Launch လိုက်ပါလေရော။ လုပ်ထားတဲ့ အိုင်ဒီယာ လေးက ကောင်းတော့ Growth က လိုက်လာတယ်။ ပြီးတော့ Hype ဖြစ်လာပြီးတော့ Features အသစ်တွေ ထည့်သင့် တာ ထည့် ဖြုတ်သင့် တာ ဖြုတ် ( နောက် မှ ဖြုတ်တာ နှမျော တတ်တဲ့ Product Owner တွေ အကြောင်း ပြော ပြမယ် မသုံးရင် အမှိုက်ပဲ ) ။ စပြီ Dev team က Rockstars တွေဆိုတော့ ထားပါ တစ်လ နှစ်လ ခံလိမ့်မယ်။ သုံးလဆို စပြီး အသံထွက်လာမယ်။ Service QOS ညံ့လာမယ် ပြီးရင် သုံးတဲ့လူတွေ ချဉ်လာမယ်( တကယ်ပြောတာ စကားလှစရာ မလိုဘူး)။

Mono လုပ်ထားတော့ Function တစ်ခုတည်းကို ကွက် ပြီး Release ရခက်လာတယ် ။ အသုံးများတဲ့ ကိုယ့်ဆားဗစ်ထဲက Function တွေကို Micro မခွဲထားဘူး။ Git branching တွေ Git tagging တွေနဲ့ ဘယ်လိုပဲ hack တစ်ခုခုကတော့ ဒုက္ခပေးနေလိမ့်မယ်။ အဲ့တော့ စောင့်ရရော။ Monthly or quarterly release cycle တွေဖြစ်ကုန်တယ်။ Product က အတက်မှာ အရှိန်နှေးသွားပြီး User acquisition ကျသွားတယ်။

Stack တစ်ခုလုံး Micro လုပ်စရာမလိုဘူး။ အချို့ main feature တွေ conventions တွေသုံးပြီး Release traffic မရှိအောင် လုပ်လို့ရတယ် သုံးသူ ပျော်အောင်ထားလို့ရမယ်။ ဒါမလို့ နှစ်နှစ်ဆယ် သုံးဆယ်လောက် ကိုယ့် ဝန်ဆောင်မှု ဆက် ပေးထားမယ် မှန်းထားရင် အစကတည်းက Micro သွားသင့်တယ်။ ဒါပေမယ့် နောက်ဆုံးတော့လည်း resources တွေ အချိန်တွေနဲ့ ကိုက်မှ လုပ်တာကောင်းတယ်။ Must ဆိုတာမျိုးတော့ ကျွန်တော်လည်း လက်မခံပါဘူး။

STACKS

Stack ရွေးရတာလည်း ခေါင်း တော့ ခြောက်ရပါတယ်။ လူတိုင်းက Agile ဆိုလို့လည်း လုပ်စရာမလိုပါဘူး။ Linkedin ရဲ့ Teams တော်တော်များများက သူတို့ နဲ့ကိုက်တဲ့ Methodology ကိုု Practice လုပ်ပါတယ်။ Infra လို Team မျိုးမှာ Agile လုပ်လို့ခက်ပါလိမ့်မယ်။

၎င်းလိုပဲဲဲ Programming Launage တွေ Obsess ဖြစ်တာ လျော့ပါ။ Cool ဖြစ်တာ တွေ မဖြစ်တာတွေ က ပိုက်ဆံမပေးပါဘူး။ အသုံးကျပြီး Industry မှာ အများသုံးတယ် နောက်မှာ Community သို့မဟုတ် Google/Facebook/MS တို့လို Company တွေရှိတယ််််််််််််ဆိုတာမျိုး ။ Local မှာ ခန့်ရတာ လွယ်တာ မျိုးကို ရွေးပြီးတော့သာ လုပ်ပါ။ အထွန့်ရှည်ပါလိမ့်မယ်။

Realistic ဖြစ်ပြီး Practical ကျတဲ့ Choice မျိုးရွေးတာမျိုးက ပို ကောင်းပါတယ်။ အခြားလူတွေ ဘာတွေ ဘယ်လိုအောင်မြင်ပြီး ဘယ်လောက် မိုက်နေတယ် ဆိုတာမျိုးတွေ သိပ် မဖတ်ပါနဲ့။ ဂျင်း အော် ဆေး ဖြစ်တတ်ပါတယ်။ ကိုယ့် Team က ဘာ Comfortable ဖြစ်လည်း ပဲ မေး။ ဘယ်ကို ကြည့် ကြည့် ညာကို ကြည့်ကြည့် သူတို့ပဲ ရှိတာ သူတို့ ပဲ ကူ မှာ တခြား အွန်လိုင်းပေါ်က ဂျင်း တွေလာလုပ်ပေးမလား မေးကြည့် ဘယ်သူမှ မလာဘူး စိတ်ချ။

HOW MICRO?

တော်တော်များများက Micro ဆိုတာနဲ့ Monolithic App တစ်ခုတည်းမှာပဲ Modules တွေခွဲပြီး အဲ့ ​Modules အချင်းချင်း စကားပြောတာမျိုး ဖိုဒါခွဲတာမျိုး တွေ ထင်နေကြပါတယ်။ ဒါမှမဟုတ် ထပ် အဆင့်မြင့်သွားရင် တော့ API calls တွေပါ ခွဲပြီး Mono framework instance နှစ်ခု လုပ်ရင် လုပ်ထားမယ် ပြီး ရင် Micro ဆိုအော် တော့တာပဲ။ ဟုတ်တော့ဟုတ်ပါတယ်။

ဒါပေမယ့် Micro ရဲ့ အနှစ်သာရ မဟုတ်သေးပါဘူူူး။ Persistent layers တွေကို သာ Modular/Cluster လုပ်ပါ။ Mono သုံးလို့ရပါသေးတယ်။ Persistent နဲ့ Logic Layer ကြားမှာ Middleware တွေထည့်ထား ပေးပြီး Replicate လုပ်လို့ရအောင် လုပ်ထားလိုက်ပါ။

Runtime ပါတာမျိုးတွေ ကို config တွေ ကောင်းကောင်းထိုင်ပါ။ များသောအားဖြင့် runner တွေ router တွေ တော်တော်များများက runtime heavy ပါ။ အဲ့လို Persistent နဲ့ခွဲထားမှ တခြား တစ်ခု ကို upgrade လုပ်နေရင် အသစ်တစ်ခု run ထားပြီး Down Time 0 ဖြစ်အောင် လုပ်လို့ရမှာ။ လုပ်ဖူးလား အဲ့ဒါမျိုး ?

Instagram တို့ GitHub တို့ အခြား VAS features တွေ Update လုပ်ရင် အဲ့လိုလုပ်တယ်။ Main Feature ဖြစ်တဲ့ git ops တွေ ပုံတင်တာတွေ ရော ဘယ်တော့မှ အကျမခံဘူး။ အစားထိုး run ထားတယ်။ အားလုံး automagic ဆန်အောင် real micro က လုပ်ပေးနိုင်ပါတယ်။

ဒါတင်ပဲလားဆိုတော့ အခုအဲ့ထက်ကြမ်းတာတွေလာပါပြီ Hardware Level မှာ Micro လို့ရပြီ။

BARE METAL

Engineering Talents တွေ နောက်ပိုင်း အရမ်းများ လာတော့ လူတွေက runtime တွေ နောက်ထိသွား စဉ်းစားနေကြပြီ။ OS နောက်ကွယ်မှာ ဘာရှိလည်း ဘယ်လိုုထပ်ပြီးတော့ Optimize လုပ်လို့ရမလဲပေါ့။ VOIP stack တွေ TCP/IP Networking Stack တွေမှာ ဆို သုံးတောင်သုံးနေပြီ Hardware Specific Functions တွေ Voice Packet Propagators တွေ Layer2 translators တွေ အများကြီး။

ဘာလို့ Service တွေက မလုပ်ကြတာလည်း?

ကိုယ့်ကိုကို မေးပြီး ရှာလိုက်တော့ အရင်ကတည်းက သိတဲ့ Nix ကို ပြန်စမ်း ဖြစ်တယ်။ Atomic Upgrades ရတယ်။ OS snapshots မဟုတ်ဘူးနော် ။ ဒါက ပိုကြမ်းတယ်။ Ops သမားတွေ ကြည့်သင့် တယ်။

နောက်တစ်ခု အမိုက်ဆုံးက CLIVE။ ဒီပိုစ့် ရေးတာ ကိုက ဒီ Software ကို မှတ်မိအောင် လို့ရေးတာ။ မေ့သွားမဆိုးလို့။ သူက OS layer မရှိတော့ဘူး။ Software ကို Deps တွေနဲ့ အတူ သူက Compile လုပ်မယ်။ Network ဆို Socket ပါလာမယ် အကယ်လို Web Server လိုမျိုး Run မယ်ဆိုရင်ပေါ့။ Pipe တွေ IO တွေ ရှိသေးတယ်။ ဖိုင်တွေ IO ​တွေ လုပ်လို့ရသေးတယ် ။ ဒါပေမယ့် လုံးဝ OS အဆင့် ရောက် တဲ့ထိ Higher Level Abstractions တွေမပါတော့ဘူး ။ အရမ်းပေါ့ အရမ်း မြန် အဲ့ဒါမျိုး။ Security ကလည်း DSL ဆန်ဆန် လုပ်ရတာ ခေါင်းမစားတော့ဘူး။

Query ခေါ်ရင် channels တွေသွားမယ်။ Web route တွေဆို Network Interface နဲ့ ချိတ်ထားတဲ့ Channel ပေါ့။ Disk IO အတွက် IO Pipe တစ်ခု ရှိမယ်။ ဖိုင်ရေးတာ တစ်ခု ဖတ်တာတစ်ခု ကူးတာ တစ်ခု ဖြတ်တာတစ်ခု ထားလို့တောင်ရသေးတယ် race မှာ ကြောက်ရင်။ စမ်းကြည့် ပါ။

Hardware ပေါ်မှာ Micro Dance လို့ရပါတယ်။ Real World Project ပြီးရင် Update လုပ်ပေးပါဦးမယ်။

original post = https://medium.com/@talnet_/baremetal-service-stack-aka-nos-82facab2dd21

ကျေးဇူးတင်ပါတယ် / တင်အောင်လင်း

industry ထဲမှာ developer တစ်ယောက်အနေနဲ့ ဘယ်လို ရပ်တည်ကြမလဲ

Industry လို့ပြောရရင် သူက အကျယ်ကြီး။ Enterprise, Financial, Security, Medical, Health Informatics, AI and Robotics, Agriculture, M&E, Government စသည်ဖြင့် ကဏ္ဍတွေက ခွဲထားတာ အများကြီးပါ။ အဲဒီတော့ ဘာတွေသိဖို့/ရှိဖို့ လိုလဲ။

Skillset

သူ့ကိုတည်ဆောက်တဲ့နေရာမှာ Skillset နှစ်မျိုး ကွဲထွက်လာပါတယ်။ Horizontal Skillset နဲ့ Vertical Skillset။ အဲဒါကျတော့ နယ်ပယ်မှာမူတည်ပြီးတော့ ဘယ်ဟာကတော့ Vertical ဘယ်ဟာကတော့ Horizontal စသည်ဖြင့် ကွဲသွားပါတယ်။

Vertical Skillset

ဒဗလော့ပါ ဖြစ်ချင်တဲ့သူတွေအတွက် ဒီခေါင်းစဉ်နဲ့ ပတ်သက်ပြီး နမူနာပြောရရင် Programming နဲ့ Software Engineering က Vertical ဖြစ်မယ်။ ဘာကြောင့်လဲဆိုတော့ industry သာ ပြောင်းမယ် နယ်ပယ်သာ မတူတယ်၊ အဲဒီ Software Engineering Methodology တွေ Practice တွေက မပြောင်းဘူး။ အဲဒီမှာ ပြောစရာက vertical skill တစ်ခုထက်မက ရှိနိုင်တယ်။ တစ်ချို့က tooling ကို နိုင်တယ်၊ တစ်ချို့ကျ database design၊ တစ်ချို့ကျတော့လည်း design pattern စသည်ဖြင့်။ Network Engineer ဖြစ်ချင်တဲ့သူတွေကျ Network Design, IP Management and Auditing, Routing and Switching, Firewall စသည်ဖြင့် အဲဒါတွေက vertical ဖြစ်မယ်ပေါ့။

Horizontal Skillset

ဒါဆိုအပေါ်ကနမူနာကိုပဲ ပြန်ဆက်ကြမယ်။ ဒဗလော့ပါအတွက် Horizontal Skill တွေက ဘာတွေဖြစ်နိုင်မလဲ။ Accounting Software ရေးရင် Accounting သိအောင် လေ့လာရတယ်၊ Ledger ဘယ်လိုမှတ်လဲ P&L ဘယ်လိုတွက်လဲ စသည်ဖြင့်။ Health Care တို့ Medical နဲ့ ဆိုင်တဲ့ Software တို့တွေ ဖန်တီးမယ်ဆိုရင် ဆရာဝန်တွေက လူနာတွေကို ဘယ်လိုကြည့်တယ်၊ ဘယ်လို မှတ်တမ်းမှတ်တယ်၊ follow-up ကတော့ ဘယ်လိုလုပ်တယ်၊ Report ကတော့ ဘယ်လိုယူတယ်၊ Manufacturing တို့ Inventory တို့ Human Resource Management တို့ စသည်ဖြင့် အဲဒီနယ်ပယ်မှာ အဲဒီလုပ်ငန်းက ဘယ်လိုလည်ပတ်လဲ ဘယ်လိုအလုပ်လုပ်လဲ ဘာတွေသိဖို့လိုလဲ ဘယ်သူတွေနဲ့ ပူးပေါင်း ဆောင်ရွက်ရမလဲ၊ အဲဒါတွေက horizontal တွေဖြစ်မယ်။ Network Operation Support မှာ လုပ်တဲ့သူတွေဆို Networking နဲ့ဆိုင်တဲ့ ဗဟုသုတ လိုမယ်ပေါ့ 7-layer တို့ sub-netting တို့ လိုအပ်ရင် script တွေရေးဖို့လိုတဲ့သူတွေကျ Programming စသည်ဖြင့်ပေါ့။

အဲဒီတော့ vertical skillset ဆိုတာ ကိုယ် ကျွမ်းကျင်ပိုင်နိုင်တဲ့အရာမျိုး၊ horizontal skillset ဆိုတာ ကိုယ့်ရဲ့ အလုပ်နဲ့ပတ်သက်ပြီး ဆက်စပ်သိရှိနားလည်ဖို့ လိုတဲ့အရာမျိုးလို့ ယေဘုယျ ပြောနိုင်ပါတယ်။

Hard/Soft Skills

ဒါကတော့ Skill နှစ်မျိုးပါ။ Hard skill ကို Technical Skill လို့လည်း ခေါ်ကြတယ်။ ကားမောင်းတတ်တာတို့၊ တိုင်းခြားစကား ပြောတတ်တာတို့၊ ဟင်းချက်တတ်တာတို့ စသည့် သင်ယူပြီးရရှိလာသော ကျွမ်းကျင်မှုလို့ ဆိုကြတယ်။ Soft Skill ကတော့ စာရိတ္တပိုင်းတို့၊ စီမံခန့်ခွဲမှုတို့၊ ပူးပေါင်းဆောင်ရွက်ခြင်း စတဲ့ လူတွေရဲ့ ပင်ကိုယ်လက္ခဏာ (Personality) နဲ့ ပတ်သက်တဲ့ skill လို့ ခေါ်ကြတယ်။

Domain Knowledge

ဒီဟာကိုတော့ လုပ်ရင်း ကိုင်ရင်းနဲ့ပဲ သင်ယူရတာပါပဲ။ ဒီ system ကြီး ဘယ်လို လည်ပတ်လဲ၊ ဘယ်လိုတည်ဆောက်ထားလဲ၊ workflow က ဘယ်လိုလဲ၊ သူ့ရဲ့ business policy တွေက ဘယ်လိုမျိုးလဲ၊ ဒီ စနစ်ကြီးလည်ပတ်ဖို့ ဘယ် team တွေ ပူးပေါင်းဆောင်ရွက်နေလဲ။ သူ့မှာ ဘယ်လို အကန့်အသတ်တွေ၊ ဆောင်ရွက်လို့မရတာတွေ ရှိလဲ။ ဒီ Domain Knowledge ကျတော့ industry တစ်ခုမှာ အချိန်ကာလ တစ်ခုပေးပြီး ရလာတဲ့ အတွေ့အကြုံ၊ ဗဟုသုတပေါ့ဗျာ။

အနှစ်ချုပ်ရရင်တော့ Software Engineering (+ data structure) + domain knowledge အဲဒါတွေလိုပါတယ်။ Skill ဘယ်လိုတည်ဆောက်ရမလဲဆိုရင်တော့ vertical skillset နဲ့ horizontal skillset ရှိပါတယ်။ ကိုယ် ကျွမ်းကျင်တာက ဒါမှမဟုတ် ကျွမ်းကျင်ပိုင်နိုင်ချင်တာက ဘာတွေလဲ။ ဘယ်ဟာတွေကတော့ အလုပ်နဲ့ ပတ်သက်ပြီး ဆက်စပ်သိဖို့လိုလဲ။ ကိုယ်ကရော ဘယ်လို industry မှာလုပ်ချင်တာလဲ။ အဲဒီ industry မှာရော ဘယ်လို vertical နဲ့ ဘယ်လို horizontal skill တွေ လိုအပ်လဲ။ ပြီးတော့ Hard-skill အပြင် Soft-skill ကိုရော ပြင်ဆင်ထားပြီးပြီလား။ အဲဒီလိုနဲ့ တည်ဆောက်လို့ ရတယ်ဆိုတဲ့အကြောင်း ပြောကြားရင်းနဲ့ပဲ ယခုဆောင်းပါးကို အဆုံးသတ်ပါရစေ။

လိုအပ်တာများ၊ မှားယွင်းတာများ ပါရှိနေရင်လဲ ဝေဖန်၊ အကြံပြု၊ ထောက်ပြ ပြောဆိုနိုင်ပါတယ်။

ကျမ်းမှီး။
https://en.wikipedia.org/wiki/Domain_knowledge
https://en.wikipedia.org/wiki/Soft_skills
https://en.wikipedia.org/wiki/Skill#Hard_skills
https://blog.crossknowledge.com/horizontal-vertical-development/

Learn Data Structure In Burmese

မှတ်ချက် – ဒီ Post သည် Draft Publish ဖြစ်သည်။ တစ်ချို့အပိုင်းများ ဘာသာပြန်ဖို့လိုအပ်နေသေးသည်။ ဖြစ်နိုင်ရင် Feedback ပေးစေချင်ပါတယ်။

ကျွန်တော်ဒီနေ့ပြောမယ့်အကြောင်းအရာတွေတော်တော်များများက itsy-bisty-data-structures ကနေကိုးကားဘာသာပြန်ပြီးတော့ရေးသားထားတာဖြစ်ပါတယ်။ English လို Study လုပ်ရတာအဆင်ပြေတဲ့သူအတွေအတွက် နဂိုမူရင်း repo ကိုသွားပြီး study လုပ်ဖို့တိုက်တွန်းလိုပါတယ်။

ကိုယ်တိုင် CS ကျောင်းဆင်းမဟုတ်တာကြောင့် Data Structure/Algorithm ဘက်မှာအားနည်းတယ်လို့ခံစားရတယ်။ နောက်တကယ်အလုပ်လုပ်တဲ့အခါမှာလည်း ဒါတွေသိတာမသိတာဘယ်လောက်အရေးပါလဲဆိုတာ သိလာတွေကြောင့်ရယ် သေချာလိုက်လုပ်ဖြစ်ရင်း ဒီ repo က အတိုဆုံးနှင့် နားလည်အလွယ်ဆုံးဖြစ်တာကြောင့် မြန်မာလိုလေးပါရှိရင်ကောင်းမယ်ဆိုပြီး စဥ်းစားမိလို့ဘာသာပြန်တာလိုလို ကိုးကားတာလိုလိုလုပ်ပြီးရေးဖို့စဉ်းစားဖြစ်ပြီး ရေးဖြစ်သွားတာပါ။

ကျွန်တော်တို့ Data Structure တွေကောင်းကောင်းမသိဘူးဆိုရင်… algorithm problem တွေ solve လုပ်တဲ့နေရာမှာအတော်သိသာတယ်။ ဥပမာ ကိုယ်သိတဲ့ data structure နှင့် solve လုပ်ဖို့အရမ်းခက်ခဲနေတာမျိုးပေါ့။

Data Structure တွေများများသိထားတော့ ပြဿနာတစ်ခုကိုဖြေရှင်းပြီဆိုလျှင် ကိုယ်သိတဲ့ data structure တွေကိုလိုအပ်တဲ့နေရာမှာလိုအပ်သလိုသုံးတော့ ကိုယ့်ကုဒ်ကမရှုပ်ထွေးနေတော့ဘူးပေါ့။ လွယ်လွယ်ကူကူဖြစ်နေတယ်ပေါ့။

အခုကျွန်တော်တို့ data structure တွေကိုလေ့လာဖို့ အသုံးများတဲ့ data structure တွေကို JavaScript သုံးပြီးကိုယ်တိုင် implement လုပ်ကြမယ်။ တစ်ခြား language နှင့်လုပ်မယ်ဆိုလည်း idea ကအတူတူပဲဖြစ်လို့ကိုယ်ကြိုက်တဲ့ Language နှင့် implement လုပ်နိုင်ပါတယ်။ ကျွန်တော်ကတော့ မူရင်း repo က JavaScript အတိုင်းပဲ ဘာသာပြန်ပါ့မယ် 😄။

Data structure ဆိုတာဘာလဲ

Wikipedia မှာတော့ Data Structure ဆိုတာ Data တွေကို Store (သိမ်းဆည်းဖို့) နှင့် efficiently access/modification လုပ်နိုင်တဲ့ Data Organization တစ်ခုဖြစ်တယ်လို့မှတ်သားရပါတယ် (ဘာသာပြန်တာမှားကောင်းမှားနိုင်လို့ ကိုယ်တိုင် Wikipedia မှာရှာဖွေဖတ်ရှုစေချင်ပါတယ်)။

ကျွန်တော်တို့ Data တွေကို နည်းမျိုးစုံနှင့်ဖော်ပြနိုင်တယ်။ ဒါပေမယ့် ဒီ data ကဘာလဲ အဲ့ဒါကိုဘယ်နေရာအတွက်သုံးမှာလဲပေါ်မူတည်ပြီးတော့ ဘယ်လို data structure ကိုအသုံးပြုမလဲဆိုတာကိုဆုံးဖြတ်ရပါမယ်။ Data Structure တွေမှာလည်း သူ့အားသာတဲ့အပိုင်း၊ အားနည်းတဲ့အပိုင်းရှိတာမို့လို့ ကိုယ်အသုံးပြုလိုတဲ့အပေါ်မူတည်ပြီးအသင့်တော်ဆုံး data structure ကိုယူသုံးရပါမယ်။

အဲဒီအားသာချက်၊ အားနည်းချက်တွေကိုနားလည်ဖို့ရာအတွက် algorithms အကြောင်းနည်းနည်းပြောလိုက်ရအောင်။

ALGORITHMS

ALGORITHMS

ပထမဆုံး Algorithm ဆိုတာဘာလဲက စမယ်။ Algorithm ဆိုတာ ဒါပြီးရင် ဒါလုပ် ဒါပြီးရင် ဒါလုပ်ဆိုတဲ့ sets of operations တွေကိုထွင်ပြီးခေါ်တာပါ 🤣။

Data structure နှင့် Algorithm တွေ ဘယ်လိုဆက်စပ်နေလဲဆိုလျှင် Data structure တွေကို algorithm တွေနှင့်တည်ဆောက်ထားတာဖြစ်ပြီးတော့ algorithm တွေကို data structure တွေနှင့် တည်ဆောက်ထားတာဖြစ်ပါတယ်။ (အပြန်အလှန်ပဲပေါ့ 😀)

ဘယ်လို Task တစ်ခုပေးလိုက်ပေးလိုက် အဲဒါကိုဖြေရှင်းဖို့ မြောက်များစွာသောနည်းတွေရှိပါတယ်။ လူတွေက ယေဘုယျအားဖြင့် (ပုံမှန်အသုံးလိုတဲ့) task တစ်ခုပေးလိုက်တယ်ဆိုလျှင် တစ်ယောက်တစ်မျိုးစီ အဲ့ task ကိုဖြေရှင်းဖို့နည်းတွေထွက်လာပါတယ်။

ဥပမာ၊ unsorted item တွေကို sort လုပ်ဖို့ရာအတွက် algorithms တွေက နည်းတာမဟုတ်ဘူး… အောက်က sorting algorithm တချို့ကို ကြည့်လိုက်ရအောင်…

Insertion Sort, Selection Sort, Merge Sort, Bubble Sort, Heap Sort,
Quick Sort, Shell Sort, Timsort, Bucket Sort, Radix Sort, ...

ဒီ sorting နည်းတွေထဲမှာဆိုလျှင် တချို့ algorithm တွေက တချို့ algorithm တွေထက် ပိုမြန်တယ်။ တချို့ algorithm က memory အသုံးပြုမှုနည်းတယ်။ တချို့ algorithm က လွယ်လွယ်ကူကူ implement လုပ်နိုင်တယ်။ တချို့က dataset နှင့် ပတ်သက်တဲ့ assumption ေပါ် အခြေခံထားတယ်။

ဒီ algorithm တွေမှာ တစ်ခုက တစ်ခုထက် တချို့အရာတွေမှာ ပိုကောင်းတယ်။ ဒါကြောင့် ဒီ algorithm တွေကို ကိုယ့်လိုအပ်ချက်ပေါ်မူတည်ပြီး ဘယ်ဟာကို သုံးရမလဲဆိုပြီး ဆုံးဖြတ်ဖို့ရာအတွက် အဲဒါတွေကို တိုင်းတာဖို့ နည်းတစ်ခုလိုတယ်။ Algorithm တွေရဲ့ ပျမ်းမျှနှင့် အဆိုးဆုံးအခြေအနေ စွမ်းဆောင်ရည်တွေကို တိုင်းတာဖို့ရာအတွက် “Big-O” လို့ခေါ်တဲ့ တိုင်းတာမှုကို သုံးတယ်။

အခု အောက်မှာ Big O Notation အကြောင်း နည်းနည်းထပ်ရှင်းပြမယ်…

BIG-O NOTATION

## Big-O Complexity Chart by http://bigocheatsheet.com/

Algorithm တစ်ခုနှင့်တစ်ခု ဘယ် algorithm ကပိုမြန်တယ်/ပိုနှေးတယ်ဆိုတာတွေကို ယေဘူယျအားဖြင့်တိုင်းတာဘဲ ဖြစ်ဖြစ် အချင်းချင်းဘယ်ဟာကတော့ပိုနှေးတယ်ပိုမြန်တယ်ဆိုတာပြီး Discuss လုပ်တဲ့နေရာမှာဘဲဖြစ်ဖြစ် Big-O Notation ကို ကျွန်တော်တို့အသုံးပြုကြတယ်။

Big-O ဆိုတာ သင်္ချာသင်္ကေတတစ်ခုပါဘဲ။ ဒါကို computer science မှာ algorithm တစ်ခုမှာ input (ပေးလိုက်တဲ့ number) (N) အရေအတွက်ပေါ်မူတည်ပြီး algorithms တွေရဲ့ အမျိုးအစားကို ခွဲခြားတဲ့နေရာမှာသုံးကြတယ်။

Big-O ကို ကျွန်တော်တို့ အဓိကသုံးတဲ့ တိုင်းတာမှုနှစ်ခုရှိတယ်… အဲ့ဒါကဘာတွေလဲဆိုလျှင် Time complexity နှင့် Space complexity ဖြစ်တယ်။ အောက်မှာအဲ့နှစ်ခုရဲ့ ဆိုလိုရင်းကို တစ်ချက်နည်းနည်းထပ်ပြောပြထားတယ်။

Time complexity ဆိုတာ algorithm မှာ ပေးလိုက်တဲ့ items ပေါ်မူတည်ပြီး operate လုပ်တဲ့အရေအတွက်ကိုတွက်တာကိုပြောတာဖြစ်တယ်။

Space complexity ဆိုတာ ပေးလိုက်တဲ့ items ပေါ်မူတည်ပြီး memory ဘယ်လောက်အသုံးပြုလဲဆိုပြီး တွက်တာကိုပြောတာဖြစ်တယ်။

ဘာလို့ Time complexity နှင့် Space complexity ကိုခွဲထားတာလဲဆိုလျှင် algorithm တွေက operate လုပ်တာနည်းပေမယ့် memory space အများကြီးယူနိုင်တယ် တစ်ခုနှင့်တစ်ခုမတူဘူး ဒါကြောင့်ကိုယ်လိုအပ်တဲ့နေရာမှာ ဒီနှစ်ခုထဲကတစ်ခုပိုကောင်းလျှင်ရတယ်ဆိုတာမျိုးတွေရှိလာလျှင် ရွေးချယ်နိုင်အောင်ကြောင့်ဖြစ်တယ်။

အောက်ဖော်ပြပါ table မှာ အသုံးများတဲ့ (common ဖြစ်တဲ့) Big-O တွေကို ကြည့်ကြည့်ရအောင်…

အခေါ်အဝေါ်သင်္ကေတအဆိုး/အကောင်း/အကြိုး/အကြောင်း
ConstantO(1)AWESOME!!
LogarithmicO(log N)GREAT!
LinearO(N)OKAY
LinearithmicO(N log N)UGH…
PolynomialO(N ^ 2)SHITTY
ExponentialO(2 ^ N)HORRIBLE
FactorialO(N!)WTF

အခုပြောနေတာတွေကိုထင်းကနဲလင်းကနဲမြင်သာအောင် Example ပေးကြည့်မယ်။ ကျွန်တော်တို့ (N) အရေအတွက်ရှိတဲ့ items တွေကိုထည့်လိုက်ရင်ဘယ်လောက်ကြာလဲဆိုတာကိုအောက်ဖော်ပြပါ table မှာတစ်ချက်ကြည့်လိုက်ရအောင်။

Big ON = 5N = 10N = 20N = 30
O(1)1111
O(log N)2.3219…3.32194.3219…4.9068…
O(N)5102030
O(N log N)11.609…33.219…84.638…147.204…
O(N ^ 2)25100400900
O(2 ^ N)3210241,048,5761,073,741,824
O(N!)1203,628,8002,432,902,0…265,252,859,812,191,058,636,308,480,000,000

အခုမြင်တဲ့အတိုင်းဘဲ data sets လေးနည်းနည်းလေးတောင်မှ extra works တွေဘယ်လောက်လုပ်ရလဲဆိုတာမြင်နိုင်ပါတယ်။

Data structure တွေကိုအသုံးပြုပြီး အဓိကလုပ်တဲ့ action လေးခုရှိပါတယ်။ ဘာတွေလည်းဆိုရင် Accessing, Searching, Inserting, နှင့် Deleting တို့ဘဲဖြစ်ပါတယ်။

နောက်ထပ်မှတ်သားထားရမှာက data structure တွေက တစ်ချို့ action တွေမှာကောင်းပြီးတော့တစ်ချို့ action တွေမှာဆိုးချင်ဆိုးမှာဆိုတာပါ။

Data structureAccessingSearchingInsertingDeleting
ArrayO(1)O(N)O(N)O(N)
Linked ListO(N)O(N)O(1)O(1)
Binary Search TreeO(log N)O(log N)O(log N)O(Log N)

ဒါမှမဟုတ်… ပိုမြင်သာအောင်အောက်က table ကိုတစ်ချက်ကြည့်လိုက်အောင်…

Data structureAccessingSearchingInsertingDeleting
ArrayAWESOME!!OKAYOKAYOKAY
Linked ListOKAYOKAYAWESOME!!AWESOME!!
Binary Search TreeGREAT!GREAT!GREAT!GREAT!

တစ်ချို့ actions တွေက different “average” performance နှင့် “worst-case scenario” performance ဆိုပြီးရှိပါတယ်။

Perfect data structure ဆိုတာမရှိပါဘူး။ Data Structure တွေကိုရွေးတဲ့အခါမှာ ကိုယ် Handle လုပ်နေရတဲ့ data နှင့် ကိုယ်ကဒီ Data ကိုဘယ်မှာအသုံးပြုမလဲပေါ်မူတည်ပြီးရွေးရပါတယ်။ ဒါကြောင့်မလို့ common data structures တွေကိုသိထားဖို့အရေးကြီးပါတယ်။ ဒါမှကိုယ်လိုအပ်တဲ့အခါ အဲ့ဒီ့ data structure ထဲကရွေးရမှာမလို့ဖြစ်ပါတယ်။

MEMORY

MEMORY

ကွန်ပျူတာ Memory ဆိုတာနည်းနည်းပျင်းစရာကောင်းပါတယ်၊ order slots တွေထဲမှာ information တွေသိမ်းထားနိုင်တဲ့နေရာတစ်ခုပါဘဲ။ ကိုယ်လိုချင်တဲ့ information တွေကိုရနိုင်ဖို့ memory address သိဖို့လိုပါတယ်။

Memory Chunk တစ်ခုကိုအောက်ဖော်ပြပါအတိုင်းဖြစ်တယ်လို့ယူဆလိုက်ရအောင်…

Value1001011010000100010110100010000111011011
Address0123456789

Programming language တွေမှာ 0 index နှင့်ဘာလို့စလဲဆိုပြီးစဥ်းစားပြီးအဖြေမရခဲ့ဘူးဆိုရင် အခုအဖြေရပါပြီ ဘာလို့လဲဆိုတော့ Memory ကအဲ့လိုအလုပ်လုပ်လို့ပါတဲ့။

LISTS

LISTS

Memory နှင့် data structure တစ်ခု raw interaction ဘယ်လိုအလုပ်လုပ်လဲဆိုတာ demonstrate လုပ်ဖို့ရာအတွက် List တစ်ခု implement လုပ်ပါ့မယ်။

A list is a representation of an ordered sequence of values where the same value may appear many times.

class List {

    /**
     * Memory အလွတ်တစ်ခုကို JS Array အနေဖြင့်အသုံးပြုပြီးတော့ List ရဲ့ length ကိုလည်း store လုပ်ထားမှာဖြစ်ပါတယ်။
     * 
     * မှတ်သားစရာက ကျွန်တော်တို့ length ကိုသတ်သတ်သိမ်းထားတာပါဘဲ။ ဘာလို့လဲဆိုရင် memory ကနေ Length ဖတ်လို့မရလို့ပါဘဲ။
     */

    constructor() {
        this.memory = [];
        this.length = 0;
    }

    /**
     * ကျွန်တော်တို့ List ကနေပြီးတော့ data တွေကို retrieve လုပ်ဖို့နည်းလိုပါလိမ့်မယ်
     * 
     * Address တွေကို Keep Track လုပ်တာဖြစ်တဲ့အတွက်ကြောင့်မလို့ Very fast memory access ရမှာဖြစ်ပါတယ်။
     * 
     * List ကို access လုပ်တာက constant O(1) - "AWESOMW!!"
     */

    get(address) {
        return this.memory[address];
    }

    /**
     * List က order ရှိတာကြောင့်မလို့ အစ၊ အလယ်၊ အဆုံးမှ data တွေကို insert လုပ်နိုင်ပါတယ်။
     * 
     * ကျွန်တော်တို့ရဲ့ implementation မှာတော့ values တွေရဲ့ adding/removing ကို အစ သို့မဟုတ်
     * အဆုံး ကို focus ထားမှာဖြစ်ပြီးတော့ အောက်ဖော်ပြပါ method လေးမျိုးကိုအသုံးပြုသွားမှာဖြစ်ပါတယ်။
     * 
     *  - Push    - Value တစ်ခုကိုနောက်ဆုံးမှ Add လုပ်တဲ့နေရာမှာ
     *  - Pop     - Value တစ်ခုကိုနောက်ဆုံးမှ Remove လုပ်တဲ့နေရာမှာ
     *  - Unshift - Value တစ်ခုကိုအစကနေထည့်တဲ့နေရာမှာ
     *  - Shift   - Value တစ်ခုကိုအစကနေ Remove လုပ်တဲ့နေရာမှာ
     */

    /**
     * Push ကအနေစလိုက်မယ်ဆိုရင် ကျွန်တော်တို့ value ကို list ရဲ့နောက်ဆုံးမှာထည့်လိုက်ရအောင်...
     * 
     * ကျွန်တော်တို့ List ရဲ့နောက်ဆုံးကို Item တစ်ခုထည့်တာက အတော်လေးရိုးရှင်းပါတယ်။ ကျွန်တော်တို့ 
     * လွယ်လွယ်ကူကူတွက်လို့ရတဲ့ length ကို store လုပ်တယ်။ Add the value and increment
     * the length ရှင်းရှင်းလေးပါဘဲ။
     * 
     * Item တစ်ခုကို Push လုပ်တာက constant O(1) - "AWESOME!!"
     */

    push(value) {
        this.memory[this.length] = value;
        this.length++;
    }

    /**
     * ဆက်လက်ပြီးတော့ implement လုပ်ရမှာကတော့ ကျွန်တော်တို့ List ထဲက items တွေကိုနောက်ဆုံးမှ 
     * pop လုပ်ဖို့ဘဲဖြစ်ပါတယ်။
     * 
     * push နှင့်အတော်လေးတူပါတယ်။ List နောက်ဆုံး Value ကနေပြီးတော့ 
     *
     * Item တစ်ခုကို နောက်ဆုံးမှ popping လုပ်တာက constant O(1) - "AWESOME!!"
     */

    pop() {
        // ကျွန်တော်တို့ list ထဲမှာဘာမှမရှိရင်ဘာမှမလုပ်ဘူးပေါ့...
        if(this.length === 0) return;

        // နောက်ဆုံး item ကိုယူမယ်, ဖျက်မယ် ပြီးရင် သိမ်းထားတဲ့ value ကို return ပြန်မယ်...
        let lastAddress = this.length - 1;
        let value = this.memory[lastAddress];
        delete this.memory[lastAddress];
        this.length--;

        // Value ကို return ပြန်လိုက်တော့ ဒီ Value ကိုသုံးချင်သုံးလို့ရတာပေါ့
        return value;
    }

    unshift(value) {
        let previous = value;
        for(let address = 0; address < this.length; address++) {
            let current = this.memory[address];
            this.memory[address] = previous;
            previous = current;
        }

        this.memory[this.length] = previous;
        this.length++;
    }

    shift() {
        if(this.length === 0) return;

        let value = this.memory[0]

        for(let address = 0; address < thisl.length -1; address) {
            this.memory[address] = this.memory[address + 1];
        }

        delete this.memory[this.lenth - 1];
        this.length--;

        return value;
    }   
}

ကျွန်တော်တို့တွေ့ခဲ့တဲ့အတိုင်းဘဲ Lists တွေက fast access နှင့် နောက်ဆုံး items တွေနှင့် deal တာကောင်းပါတယ်။ သို့ပေမယ့် နောက်ဆုံး items မဟုတ်တဲ့ Value တွေနှင့် deal လုပ်တဲ့နေရာမှာ အဲ့လောက်မကောင်းတာကိုတွေ့ရမှာပါ။ ကျွန်တော်တို့

HASH TABLES

HASH TABLES
class HashTable {

    constructor() {
        this.memory = [];
    }

    hashKey(key) {
        let hash = 0;
        for(let index = 0; index < key.length; index++) {
            let code = key.charCodeAt(index);
            hash = ((hash << 5) - hash) + code | 0;
        }
        return hash;
    }

    get(key) {
        let address = this.hashKey(key);
        return this.memory[address];
    }

    set(key, value) {
        let address = this.hashKey(key);
        this.memory[address] = value;
    }

    remove(key) {
        let address = this.hashKey(key);
        if(this.memory[address]) {
            delete this.memory[address];
        }
    }

}

STACKS

STACKS
class Stack {

    constructor() {
        this.list = [];
        this.length = 0;
    }

    push(value) {
        this.length++;
        this.list.push(value);
    }

    pop() {
        if(this.length === 0) return;

        this.length--;
        return this.list.pop();
    }

    peek() {
        // နောက်ဆုံး item ကို remove မလုပ်ဘဲ return ပြန်မယ်
        return this.list[this.length - 1];
    }
}

QUEUES

Queue
class Queue {

    /**
     * ကျွန်တော်တို့ queue က memory အစား JavaScript ရဲ့ array ကို list အဖြစ်အသုံးပြုထားပါတယ်။
     */

    constructor() {
        this.list = [];
        this.length = 0;
    }

    enqueue(value) {
        this.length++;
        this.list.push(value);
    }

    dequeue() {
        if(this.length === 0) return;

        this.length--;
        return this.list.shift();
    }

    peek() {
        return this.list[0]
    }
}

GRAPHS

GRAPHS
class Graph {

    constructor () {
        this.nodes = []'
    }

    addNode() {
        return this.nodes.push({
            value,
            lines: []
        });
    }

    find() {
        return this.nodes.find(node => {
            return node.value === value;
        });
    }

    addLine(startValue, endValue) {
        let startNode = this.find(startValue);
        let endNode = this.find(endValue);

        if(!startNode || !endNode) {
            throw new Error('Both nodes need to exist');
        }

        startNode.lines.push(endNode);
    }

}

LINKED LISTS

LinkedList
class LinkedList {

    constructor() {
        this.head = null;
        this.length = 0;
    }

    get(position) {
        if(position >= this.length) {
            throw new Error('Position outside of list range');
        }

        let current = this.head;

        for (let index = 0; index < position; index++) {
            current = crrent.next;
        }

        return current;
    }

    add(value, position) {
        let node = {
            value,
            next: null
        };

        if(position === 0) {
            node.next = this.head;
            this.head = node;
        } else {
            let prev = this.get(position - 1);
            let current = this.next;
            node.next = current;
            prev.next = node;
        }

        this.length++;
    }

    remove(position) {
        if(!this.head) {
            throw new Error('Removing from empty list')
        }

        if(position === 0) {
            this.head = this.head.next;
        } else {
            let prev = this.get(position - 1);
            prev.next = prev.next.next;
        }

        this.length--;
    }

}

TREES

TREES
class Tree {
    constructor() {
        this.root = null;
    }

    traverse(callback) {
        function walk(node) {
            callback(node);

            node.children.forEach(walk);
        }

        walk(this.root);
    }

    add(value, parentValue) {
        let newNode = {
            value,
            children: []
        };

        if(this.root === null) {
            this.root = newNode;
            return;
        }

        if(this.traverse(node => {
            if(node.value === parentValue) {
                node.children.push(newNode);
            }
        });
    }
}

BINARY SEARCH TREES

BINARY SEARCH TREES
class BinarySearchTree {
    constructor() {
        this.root = null;
    }

    contains(value) {
        let current = this.root;

        while (current) {
            if (value > current.value) {
                current = current.right;
            } else if(value < current.value) {
                current = current.left;
            } else {
                return true;
            }
        }

        return false;
    }

    add(value) {
        let node = {
            value: value,
            left: null,
            right: null
        };

        if(this.root === null) {
            this.root = node;
            return;
        }

        let current = this.root;

        while(true) {
            // If the value is greater than the current value we move to the right.
            if(value > current.value) {

                // If `right` does not exist, set it to our node, and stop travesing.
                if(!current.right) {
                    current.right = node;
                    break;
                }

                current = current.rigth;

                // If the value is less than the current.value we move to the left.
            } else if (value < current.value) {

                // If `left` does not exist, set it to our node, and stop traversing.
                if (!current.left) {
                    current.left = node;
                    break;
                }

                current = current.left;
            } else {
                break;
            }
        }
    }
}

နိဂုံး

YGNCode.com (ကြော်ငြာ)

ပထမဆုံး ကျွန်တော့်ဘာသာပြန်ကိုအဆုံးထိဖတ်ပေးလို့ကျေးဇူးတင်ပါတယ်။ Computer Science နှင့်ပါတ်သတ်တာတွေကို မြန်မာလိုလေ့လာချင်တယ်ဆိုရင် www.ygncode.com လာရောက်ဖတ်ရှုဖို့ဖိတ်ခေါ်ပါတယ်။ အခုလိုမြန်မာလိုဘာသာပြန်တွေတင်မက အင်တာဗျူးပြင်ဆင်ဖို့ Algorithms တွေအပြင် အသုံးဝင်တဲ့ Website တွေ YouTube တွေပါပြန်လည်မျှဝေပေးလျှက်ရှိပါတယ်။

ကျေးဇူးတင်ပါတယ်

ပထမဦးဆုံး original ရေးသားသူ @jamiebuilds ကိုအထူးကျေးဇူးတင်ပါတယ်။ နောက်ကျွန်တော့်ဒီဘာသာပြန်ကိုပါဝင်ကူညီအားဖြည့်ပေးသော ကိုလမင်းကို ကိုကျေးဇူးအထူးတင်ပါတယ်။

ဒီဘာသာပြန်ကိုဖတ်ရှုကြသော စာဖတ်သူများကိုလည်း အထူးကျေးဇူးတင်ပါတယ်။

Cloud Computing ဘာဘယ်လဲ

မိတ်ဆက်

စာတစ်စောင်လုံး ဖတ်ပြီးတော့ အချိန် မကုန်ရလေအောင် စာတိုလေးနဲ့ နှုတ်ဆက်လိုက်ပါတယ်။ ကျွန်တော် ကတော့ တင်အောင်လင်းပါ။ သတင်း အချက်အလက် ထုတ်ကုန်တွေကို တည်ဆောက်တဲ့ နည်းပညာသမား တစ်ယောက်ဖြစ်ပါတယ်။ ယခုသုံးသပ်တင်ပြထားတဲ့ စာစုလေးဟာ နည်းပညာ ပိုင်း (Technical) ပိိုဆန်တဲ့ အတွက် IT သမား တွေ ၊ ကွန်ပျူတာ နည်းပညာကို Academic လေ့လာလိုက်စား နေတဲ့ ကျောင်းသား ကျောင်းသူ တွေ ၊ နည်းပညာ ဆိုင်ရာ ဝန်ဆောင်မှုု ပေးနေသော Business သမားတွေ အတွက် အထောက်် အကူူဖြစ်််​စေမှာပါ။

ရာဇဝင်အကျဉ်း

တကိုယ်ရည်သုံး ကွန်ပျူတာတွေ ပေါ်ထွက်လာတာဟာ 2019 မှာ နှစ်လေးဆယ်ကျော် လာပြီဖြစ်ပါတယ်။ အင်တာနက်လို (Global Computer Network) တွေကို သုံးစွဲသူ များပြားလာတဲ့အတွက် နည်းပညာရဲ့ အရေးပါမှုဟာ အင်မတန််ကြီးထွား လာခဲ့ပြီး အသစ်အသစ်သော နည်းပညာများ နှင့် နည်းပညာရှင်များ ပေါ်ထွန်းလာကာ အခု ဆိုရင် Cloud Computing Era လို့ ခေါ်ဆိုလို့ရအောင် အရာရာဟာ တိမ်တွေထဲမှာ ချိတ်ဆက် တွက်ချက်နေသလို မြန်ဆန် လာခဲ့ပြီဖြစ်ပါတယ်။

ကွန်ပျူတာ တွေဟာ လုပ်ဆောင်ချက်​ (Functions) မြောက်မြားစွာကို တစ်ပြိုင်တည်းမှာ (Concurrent) လျင်လျင်မြန်မြန် လုပ်ဆောင်နိုင်တဲ့ အတွက် သတင်းအချက်အလက်တွေ သယ်ယူ ပို့ဆောင် Transport သိမ်းဆည်းရာ တွင် အလွန်သက်သာလွယ်ကူ (Efficient) စေပါတယ်။ ၂၀၁၂ နောက်ပိိုင်း နောက်ပိုင်း ကွန်ပျူတာ Chips တွေ ဟာ Form ပုံစံ သေးငယ်လာပြီး စွမ်းဆောင်ရည် ကြီးမားလာကာ စွမ်းအင်သုံးဆွဲမှု အရမ်းသက်သာ လာတာ ကြောင့် Cloud Computing ရဲ့ အစ ဖြစ်တဲ့ Data Center တွေကို Private/Public အဖွဲ့အစည်းတွေ ဟာ အများအပြား တည်ဆောက်လာကြပါတယ်။ 

နောက်ပိုင်း Business Support Software (BSS) လုပ်ငန်းသုံး ဆော့ဝဲတွေ ကို ကွန်ပျူတာ ထဲတွင် သုံးဆွဲယုံတင်မက လုပ်ငန်းတွင်း သို့မဟုတ် လုပ်ငန်းခွဲများ ဆိုင်ခွဲများ ကြား တွင် ချိတ်ဆက် သုံးဆွဲ လာ​ရာ ၎င်းဆော့ဝဲ တွေကို တပ်ဆင်သုံးဆွဲရန် Computing Units ဆော့ဝဲ လုပ်ဆောင်မှုဝန်ဆောင် ပေးသော ကွန်ပျူတာ တွေရဲ့ လိုအပ်ချက် များပြားလာပါတယ်။ ထိုကဲ့သို့ ကွန်ပျူတာဆာဗာ Servers တွေကို ဝန်ဆောင်မှု ပေးသူတွေကို ကနဦး ခေတ်မှာ Hosting Providers တွေလို့ခေါ်ခဲ့ကြပါတယ်။

Providers ( for example, Media Temple, HostGator) တွေက သုံးဆွဲသူတွေ အတွက် များသော အားဖြင့် Static Informations (Web pages and directories) တွေကိုသိမ်းထားပေးပြီး နောက်မှာ Databases တွေနဲ့ ချိတ်ပေးတာပါပဲ။  Providers တွေအနေနဲ့ Public IP Addresses တွေကို Customers တွေငှားရမ်း ထားတဲ့ Servers နဲ့ ချိတ်ဆက်ပေးပြီး စွမ်းအင်နှင့် ကွန်ယက်ချိတ်ဆက်မှု ကို 24/7  ပေးထားခြင်းဖြင့် ဝန်ဆောင်မှုပေးပါတယ်။ သင့် Organization သို့မဟုတ် သင့် လုပ်ငန်းသုံး အချက်အလက် တွေကို ၎င်း Providers တွေမှာ တင်ထားခြင်းအားဖြင့် Public IP သို့မဟုတ် Private Tunnels တွေနဲ့ ချိတ်ဆက်သုံးဆွဲနိုင်မှာဖြစ်ပါတယ်။

သုံးသပ်ချက် အမြင်

BSS တွေ အရမ်း တွင်ကျယ် လာတာနဲ့ အမျှ SME တွေကစလို့ Banks တွေ Large Corporations တွေဟာ Cloud ( Private or Public ) Data Centers တွေ ဝန်ဆောင်မှု တွေကို မှီခိုလာရပါတယ်။ ဆော့ဝဲဲဲ ရေးသား သူတွေ ဝန်ဆောင်မှု ပေးသူတွေကို သုံးဆွဲသူတွေက ယနေ့ ခေတ်မှာ​ Cloud ချိတ်ဆက်သုံးဆွဲ ဖို့ တောင်းဆိုလာ ကြတာ မဆန်းပါဘူး။ အဓိကက ဝန်ဆောင်မှုပေးသူ တွေ နည်းပညာ ရှင်တွေက Ready ဖြစ်ပြီလား?

ယခုနှစ် ၂၀၁၇ ကနေ ၂၀၁၈ အထိ ပြည်တွင်း ဆော့ဝဲ ရေးသားသူတွေဟာ Cloud ကိုု Value Added Service (VAS) အနေနဲ့ စတင်ထည့်သွင်း ဝန်ဆောင်လာတာကို တော့တွေ့ရပါတယ်။ ဒါပေမယ့် Core Feature သို့မဟုတ် အားသာချက် အနေနဲ့ ထဲထဲဝင်ဝင် သုံးလာတာ တော့ မတွေ့ရသေးပါဘူး။ ငွေစစ်လို့တော့ရမယ် ငွေဖြည့် ငွေထုတ်တော့ လုပ်လို့မရသေးတာမျိုး။ Mobile Banking ဆိုပြီး ဘာမှသုံးစားမရတာမျိုး။ အခုတော့ တော်တော်လေး ကောင်းလာပါပြီ။ SAP လိို MS office 365 လို Trust နဲ့ Liability မြင့်တဲ့ ဆော့ဝဲ ဝန်ဆောင်ပေးသူတွေ ဝင်ရောက်လာတော့ ပြည်တွင်း လုပ်ငန်းရှင်တွေလည်း အနည်းနဲ့ အများ ယှဉ် ပြိုင်ဖို့ ကြိုးစားလာတာကို တွေ့ရတယ် ဒါပေမယ့် အားမရသေးပါဘူး။  Infrastructure နဲ့ User က အဆင်သင့်ပါ။ အင်တာနက် တွေ စျေးပေါ်လာပြီး Service Availability လဲမြင့်မားလာတာ တွေ့ရတယ်။ သိသိသာသာကို မြင့်မားလာတယ် ဒါပေမယ့် တစ်ချို့ နာမည်ကြီး Service တွေ ဘာလို့ ကျကျ နေတာလဲ ဆိုတာတော့ စဉ်းစားစရာပဲ။ Public DC တွေဖြစ်တဲ့ True DC, Huawei Cloud, Azure နဲ့ AWS လို Local Player တွေ Global Player တွေဝင်ရောက်လာ တာကိုလည်း အားရစရာ တွေ့ရပါတယ်။

ဒါပေမယ့် ဘာ့ကြောင့် Cloud ပေါ်တက်ရတာ ခက်နေပါသနည်း။ များသောအားဖြင့် မြန်မာပြည်မှာဖြစ်နေကြ နည်းပညာ အခက်အခဲ Infrastructure အခက်အခဲတော့ မဟုတ်တော့ပါဘူး။ အားလုံးဟာ Public Knowledge ပါ။ AWS လို Global Provider ကအခုဆိုရင် Certificate တွေပေး ပြီးတော့ Knowledge ကို အလကား သွားပြီး သူတို့ Documentation Website မှာသွားလေ့လာလို့ရပါတယ်။ အဓိကကတော့ နည်းပညာသမား Experts နဲ့ Architects တွေရှားတာပါ။ လွန်ခဲ့တဲ့ သုံးနှစ် လေးနှစ်က မိုဘိုင်း App လေးရေး API server လေး Run တာနဲ့ တော့မရတော့ပါဘူး။

ကျွန်တော့ အမြင်တော့ Cloud Architects တွေ Experts တွေ ပေါ်လာရမယ် ပြီးတော့ ကောင်းလာရမယ်။ နဂိုရှိပြီးသား နည်းပညာသမားတွေလည်း Cloud Oriented Architect တွေ ကို Aciquistions လုပ်လာရမယ်။ ကိုယ့်ရဲ့ဆောဝဲလ် စတည်ဆောက်ကတည်းက Network Application တစ်ခု ဆောက်သလို Defensive Procedures တွေနဲ့ Data Objects တွေကို Persistent/Non-Persistent State တွေသုံးပြီးတော့ တည်ဆောက်ရမယ်။ အရင်လို အကုန်လုံး SQL ထဲပစ်ထည့်လို့မရတော့ပါဘူး။ ဆိုတော့ အားလုံး Awareness လေးနဲနဲပိုလာမယ်။ ကိုယ်တည်ဆောက်တဲ့ Software ဝန်ဆောင်မှု တိမ်ပေါ်ရောက်မယ် မကောင်းဘူးလား? Customers တွေ Users တွေယုံကြည်ရတဲ့ High Availability ဝန်ဆောင်မှုတွေ ထည့် မပေးချင်ဘူးလား? Ok, Industry-Wide ဘယ်လို ချဉ်းကပ် ကြမလည်းဆိုတာ ကျွန်တော့်် အမြင်နဲ့ ဆွေးနွေးကြည့် ချင်တယ်။

အ​ခြေခံ နည်းပညာ

Cloud လို့ပြောလိုက်ရင် Networks အကြောင်းနည်းနည်းပါမယ်။ Virtual Private Cloud  (VPC) ဆိုတဲ့ Term ကိုသဘောကျတယ်။ အရာရာကို Hardcore Network Topology လုပ်ကြည့် စရာ မလိုပဲ Logical Connections တွေနဲ့ Service တွေတည်ဆောက်လို့ရတယ် ။ ဒါပေမယ့် Basic DNS နဲ့ Subnetting ကို တော့နားလည်စေချင်တယ်။

ဆော့ဝဲ သမား Dev တော်တော်များများကလည်းခက်တယ်။ OOP တို့ TDD တို့သာ အချိန်ပေး လေ့လာရင် လေ့လာမယ်  Network ကိုတော့ အရေးမလုပ်ချင် ကြဘူး။ ရပါတယ် အကယ်လို့ ကိုယ့် Team မှာ Ops တစ်ယောက်ပါရင် ဒါကို သူ လေ့လာပါလိမ့်မယ်။ ဒါပေမယ် ကိုယ်က တော့ Awareness လေးနဲနဲရှိစေချင်တယ်။  အဲ့လိုသာ ရှိလိုက်မယ် ဆိုရင် REST လိုဟာ မျိုးကို သုံးနေရာကနေ RPC(GRPC) လို ProtoBuf လိုဟာမျိုးတွေကို လေ့လာချင်လာမယ်  သုံးချင်လာမယ်။  Defensive Programming ကို Over-does တော့မဟုတ်ဘူး နဲနဲတော့လုပ်စေချင်တယ်။ ဘာ ကိုဆိုလိုလဲသိချင်ရင် ဒီ Article လေးဖတ်ကြည့်ပါ။ RPC လို tech ကို acquisition လုပ်ချင်ရင် Google က Team တွေဘယ်လိုလုပ်လဲ လေ့လာလို့ရတယ်။ အရမ်း ကို တော်တယ်လို့ကိုယ့်ကိုကိုထင်ရင်  Cosmos လို BlockChain က Client App တွေ Tindermint နဲ့ ဘယ်လိုစကားပြောလည်း ကြည့်ကြည့် လို့ရတယ်။ Anyway ကိုယ့် Dev life-cycle ထဲမှာ အသိလေး ဝင်သွားရင် Pro-actively လုပ်လာပါလိမ့်မယ်။ နောင်ကျရင် ဒီ Skilllsတွေဟာ REST လိုမျိုး ​JD ထဲပါလာတော့မှာပါ။ သိပ်မကြာပါဘူး အလွန်ဆုံး သုံးလေးနှစ်ပေါ့။

Ops တွေအနေ နဲ့ကလည်း အရင် ကလို Xen တို့ ESXi တို့ ကို ကောင်းကောင်းကိုင်တွယ် နေရာကနေ Containers တွေ Storage Services တွေ နည်းပညာ တွေ လေ့လာသင့်တယ်။ Inframagic လို့ ခေါ်လို့ရအောင် Self-healing Infra တွေ မဆောက်ချင်ဘူးလား။ Kubernetes ဆိုတာ နတ်မင်းကြီးမဟုတ်ပါဘူး။ အခြေခံ Containerization ကနေ စစ လေ့လာမယ် ဆိုရင် တစ်ဖြည်းဖြည်းချင်း acquisition လုပ်လို့ရပါတယ်။ ပြီးတော့ ကိုယ့် Team ကို On-board ပါလာအောင် လုပ်ဖို့ဆိုရင် ကိုယ်တိုင် ကူညီပြီး Dev တွေကို Setup လုပ်ပေးပါ။ ပြီးရင် Team lead ကို Benefits တွေပြော ပေးပါ။ ဒါက Ideal Infra ပါ။ ကိုယ့်နည်းကိုယ့် ဟန် နဲ့ Retro သွားမယ် ဆိုလည်း သွားလို့ရပါတယ်။  Anything that works ပါ။  ဒါပေမယ့် Scale-out သို့မဟုတ် Scale-up Strategy တော့ ရှိသင့်ပါတယ်။ Redentency ကိုအနည်းဆုံးတော့ Proxy Server တွေ မှာထားပါ။ DNS round-robin တွေလည်းသုံးလို့ရတယ်။ ဒါပေမယ့် server တစ်ခု ဒေါင်းလို့ အကုန် ရပ်လိုက်ရတယ်ဆိုတာတော့ သိပ်မမိုက်ဘူး။ ဘယ် Provider ပဲသုံးသုံး​ ကိုယ့်ဟာကိုယ်ပဲ host host အနည်းဆုံး Planning လေးတော့ လုပ်ပါ။  စာအုပ်ထဲ ဟိုခြစ် ဒီခြစ် လဲရပါတယ်။ ကိုယ်နားလည်ပြီးရော။  အဲ Team Lead က Plan ပေးပါဆိုရင်တော့ ကောင်းကောင်းမွန်မွန်လုပ်ပေးလိုက်ပါ။ Alien လက်ရေးတွေနဲ့ တော့မလုပ်နဲ့ပေါ့။ 

ဝန်ဆောင်မှု ပေးသူတွေ ရောင်းသူ တွေအနေနဲ့ကလည်း​ QoS(Quality of Service) ကို အနည်းနဲ့အများသိသင့်တယ်။ Technical Term နဲ့ မဟုတ်ရင်တောင် Layman Term နဲ့ ကိုယ့်ဝန်ဆောင်မှုကို Promote ဘယ်လိုလုပ်သင့်သလဲဆိုတာ အမြဲတွေးနေရမယ်။ ဒါမှ ကိုယ့် Team က ထည့်ပေး လိုက်တဲ့ Value ကို ကိုယ့် Customer က Appreciate ဖြစ်မှာ ဖြစ်ပါတယ်။ Customer Appreciation means more sales? ဥပမာ ဆိုရင် ဆိုင်ရှင် တစ်ယောက်က ဆိုပါတော့ Daily Sale ကို အခု ချုပ်မယ်ဆို Manual ချုပ်ရမယ်။ အရောင်း ပိတ်အောင် စောင့်ရမယ်။ Team က App တစ်ခု ပေးလိုက်တယ် ကြိုက်တဲ့ အချိန် ကြိုက်တဲ့ နေရာ က Sale Audit လို့ရမယ်။ ချုပ်လို့ရမယ်။ ဒါမျိုး ကို Cloud ပေါ်တင်လိုက်မှ ချုပ်လို့ရတယ်။ အချက်အလက်က မှန်မယ် ဆိုတာ မျိုး။ Value Added ဖြစ်မဖြစ် မေးခွန်းထက် Smart ဖြစ်မဖြစ် အရင်ပြော။ အရမ်း Critical ကျတာမျိုး ဆေးရုံလို စားသောက်ဆိုင်လို နေရာမျိုးတွေမှာ Value Added မဟုတ်တော့ဘူး Feature ဖြစ်သွားတာမျိုး။ ဒါကိို ပိုတွေး ပိုရေး ပိုပြောစေချင်တယ်။ ဒါမှ နောက်က လုပ်ပေးရတဲ့ Team ကလဲ IT(ငအ) တွေမဖြစ်မှာ။

ချဉ်းကပ်ပုုံ

အရမ်း Technical မဆန် လို့ စိတ်ပျက်သွားမယ််််််််ထင်တယ်။ ရေးတုန်းကတော့ မိုးလောက်ကြီးတွေ ရေးမလို့ပါပဲ။ ဒါပေမယ့် ရေးရင်းနဲ့ ပုုုုတ် လောက်ပဲ ဖြစ်သွားတယ်။ ချဉ်းကပ်ကျတော့မယ် ဆိုတော့ အားလုံးပစ်ချ ပြီး Cloud ဟဲ့ဆိုတာမျိုး မဖြစ်စေချင်လို့ Approach ကိုသုံးသပ်ချင်တာ။

Dev တွေအတွက် အဓိကကတော့ Business Logic တွေဘယ်မှာ ထားမလည်း ဆိုပြီး တိုင်ပတ်တာပဲ။ ဆာဗာ ပေါ်ထား လိုက်ရင် Software က​ အင်တာနက်မရှိရင် သုံးမရတော့တာမျိုး။ အကောင်းဆုံးနဲ့ ခက်တဲ့ နည်းလမ်းကတော့ နှစ်ခြမ်း ခွဲလိုက်ပါ။ Instant Feedback ပြန်ပေးရမယ့် Logic တွေကို Software မှာ ပဲ Local လုပ်ပါ။  Actors တွေကို ဖြစ်နိုင်သမျှ မစောင့်ရ အောင် Localized လုပ်ပါ။ မတက် သာတဲ့အဆုံး Cache ပါ။ Sync ပါ။  Caching ကခက်ပါတယ် Computing ရဲ့ One of the Holy Grails ပဲ။ ဆိုတော့ အနည်းဆုံး Sync Logic ကို Actor နဲ့ ရှင်းပါစေ။ Actor က Sync ကို စောင့်နေရတာမျိုး မဖြစ်စေချင်ပါဘူး။ UX အရ အရာရာ ဟာ မြန်နေပါစေ။ Cloud လုပ်လိုက်လို့ နှေးသွားတယ်ဆိုရင် မဟုတ်သေးပါဘူး ။ Cloud အပြစ်မဟုတ်ပါဘူး အဲ့ဒါ သင့် အပြစ်ပါ။ ကြိုက်တာလေး တစ်ခု သိမ်းထားတာ ရှိတယ် ဖတ်ကြည့်ပါ။

Ops တွေ ကတော့ အသစ်စ တည်ဆောက်တယ်ဆို လွယ်ပါတယ်။ အရာရာ ကို Redentent လုပ်မယ််ဆိုရင်တော့ မဟုတ်သေးပါဘူး။ ရှိပြီးသားကို Migrate မယ်ဆိုရင်တော့ Plan ပါပြီးတော့ Service တွေကို Containerized လိုက်တယ်ဆိုလည်း Storage ကတော့ Raid နေတုန်းပါပဲ။ အဲ့ဒါကို မှတ်ထားပါ။ Raid fail ရင် all fail ပါတယ်။ S3 bucket လိုဟာမျိုးသုံးတယ်ဆိုရင်တော့ တစ်မျိုးပေါ့။ ဒါပေမယ့် Service Source ကတော့ အနည်းဆုံး Mounted FS ကလာဦးမယ်ထင်ပါတယ်။ ဒါပေမယ့် Fundamental တွေကို အရမ်းတော့ မပစ်ခါပါနဲ့။ Kubernetes လို့ရပါတယ် ဒါပေမယ့် cluster nodes တွေကတော့ ရိုးရိုး VPS တွေပါပဲ။ ကျန်းမာရေး ဂရုစိုက်ပါ။ ELK လိုဟာမျိုး ကို အရမ်း fancy တယ်ထင်လည်း NMS တစ်ခုခုတော့သုံးပါ။ ကျမှ မထပါနဲ့။ ကျလည်း အိပ်နေလို့ရအောင် ထွင်ပါ။

ရောင်းတဲ့ လူတွေအနေနဲ့ကတော့ QoS မကောင်းသေးလည်း စိတ်မပျက်ပါနဲ့။ အဓိကက Team ကို မ Blame ပါနဲ့။ Constructive Feedback ပေးပါ။ Timeline တောင်းပါ။ အချိန် နေ့ရက် နာရီ အတိအကျ တောင်းပါ။ Team က မပေးနိုင်ရင် is on them ပါ။ ကိုယ်က ကိုယ့် SLA သို့မဟုတ် ကြေညာထဲမှာ ပေးထားတဲ့ အတိုင်း အတတ်နိုင်ဆုံး ဖြစ်အောင် Information ကူးသန်းပေးပါ။  ရောင်းသူ ဝန်ဆောင်သူ ဖြစ်တဲ့အတွက် ကတိနဲ့ စကားတော့ တည်အောင် နောက်က Implementations လိုက်ပေးပါ။ Team ကို Clear message ပေးပါ။ Team Lead ကပြန် ပြီး Feedback ပါလိမ့်မယ်။  Team ကို Customer နဲ့ စကားပြောတာမျိုး ပေးမလုပ်ပါနဲ့ ။ နှစ်ဖက်လုံးက Frustruction မြင့် နေပါပြီ။ ကြားထဲက နေ Damage Control လုပ်ပါ။ Japanese Battle Ship Yamato DMC လိုမျိုးတောင် နစ်သွားပါသေးတယ်။ ဆိုတော့ Internal ကိုယုံကြည်ပါ အားပေးပါ။ မတတ်သာရင်တော့ Management ကို တိုက်ရိုက် Feedback ပေးပါ။ အားလုံး အလုပ်လုပ်နေတာပါ ဆော့နေတာမဟုတ်ပါဘူး။ 

လေ့လာစရာ

ygncode.com ကို လာဖတ်ပါ။ ကိုစကြာ က ကောင်းတာလေး တွေရေးလွန်းလို့ ကိုယ်ကိုတိုင်လည်း စိတ်ပါပြီးလာရေးဖြစ်တာပါ။ အပိုတွေ မပြောဘူး ဒီမှာ လိုတာလေးတွေပဲ ပြောကြပါမယ်။ ကိုးကားတွေလည်း လင်ခ့် တွေ ထည့်ပေးထားပါတယ်။ ပြီးတော့ အမြဲလိုလို Hardcore လေ့လာနေရတာ ကောင်းပါတယ်။ ငယ်သေးတယ်ဆိုရင်ပေါ့ ။ ဒါပေမယ့် နောက်ပိုင်််း ခြစ်ထုတ်ပြီး အလေ့ အကျင့် နဲ့ Learn ရတာကို ပို သဘော ကျလာပါတယ်။ တခြား Coding နဲ့ မဆိုင်တာလေး တွေ လည်း လုပ်ရင်းပေါ့။

DEV တွေအတွက် Practice လုပ်မယ်ဆိုရင် ဒါလေးလုပ်ကြည့်ပါ။ Go အခြေခံရှိရင် ကောင်းပါတယ်။ မရှိလည်း Pick-up လိုက်ပေါ့။ သေမယ့် ဆေးတွေမှ မဟုတ်ပဲ။

Microservices in Go

https://medium.com/seek-blog/microservices-in-go-2fc1570f6800

Architect တွေကတော့ ဒါလေး ကောင်းတယ် ထင်တာပဲ။ ကိုယ့် အမြင်နဲ့ ကိုယ် ဖတ်ကြည့်ပါ။ လိုက်လုပ်ရမယ် ဆိုတာမျိုးတော့မဟုတ်ပါဘူး။

Building microservices in 2019 and beyond

https://www.atlassian.com/continuous-delivery/microservices/building-microservices

အဆုံးထိ ရောက်လာတယ် ဆို တော်တော် လေး စိတ်ရှည်တဲ့လူပဲ ဖြစ်တဲ့အတွက် ကျေးဇူး တင်စကားလေး တော့ ပြောပါရစေ။ ထပ်မံဆွေး နွေးလိုတာရှိရင် @talnetd နဲ့ twitter ဒါမှမဟုတ် telegram မှာ လာ ပြောလို့ရပါတယ်။ အားရင် ပြန်ပြောပါ့မယ်။ မအားရင်တော့ Sorry ပါ။

ကျေးဇူးတင်ပါတယ်
တင်အောင်လင်း

Valid Palindrome

မှတ်ချက် – ဒီ Post သည် Algorithm Interview Preparation အပိုင်းဆက်ဖြစ်သည်။

ဒီ Problem က Leetcode ရဲ့ Valid Palindrome ကို solve လုပ်ထားတာဘဲဖြစ်ပါတယ်။ ပေးထားတဲ့ String S က palindrome ဖြစ်တယ်ဆိုရင် true return ပြန်ရမှာဖြစ်ပြီးတော့ မဟုတ်ဘူးဆိုရင် false return ပြန်ရမှာဖြစ်ပါတယ်။

ဒီနေရာမှာ Palindrome ဆိုတာကိုနားမလည်ရင် Problem solve လုပ်ဖို့ရာမလွယ်ပါဘူး။ Palindrome ဆိုတာပေးထားတဲ့ string ကိုနောက်ကနေ reverse ပြန်ရင်လည်းအတူတူဖြစ်တာမျိုးကိုပြောတာပါ… အောက်ကနမူနာကိုကြည့်ရင်ပိုရှင်းမယ်ထင်တယ်။

"A man, a plan, a canal: Panama" က Palindrome ပါ
"race a car" ဆိုတာက Palindrome မဟုတ်ပါဘူး။

ကျွန်တော်တို့ဒီနေရာမှာ palindrome က backward, punctuation, case နှင့် spacing တွေကို ignore လုပ်တယ်ဆိုတာကိုလည်းတစ်ချက်သတိမူရမှာဖြစ်ပါတယ်။

တကယ်လို့ဒီမေးခွန်းကို အင်တာဗျူးမှာမေးတယ်ဆိုရင် ကျွန်တော်တို့ဘက်က empty string ဆိုရင်ကော valid palindrome ဟုတ်လားဆိုတာမျိုးမေးရမှာပါ။ များသောအားဖြင့်တော့ empty string က valid palindrome လို့သတ်မှတ်ကြပါတယ်။ ကိုယ့်ဘက်ကသေချာအောင်တော့မေးရမှာပေါ့။

ကျွန်တော်အောက်မှာ example test case လေးဖော်ပြထားပါတယ်… ကိုယ်တိုင်စမ်းသတ်ရေးကြည့်ပြီးစမ်းကြည့်နိုင်ပါတယ်။

palindrome(“race car”) should return true
palindrome(“never odd or even”) should return true
palindrome(“nope”) should return false
palindrome(“1 eye for of 1 eye.”) should return false
palindrome(“0_0 (: /-\ :) 0–0”) should return true

ကျွန်တော်ဒီ Problem ကိုဘယ်လို Solve လုပ်သလဲတစ်ချက်ကြည့်လိုက်ရအောင်…

/**
 * @param {string} s
 * @return {boolean}
 */
var isPalindrome = function(s) {
    var s = s.replace(/[^a-zA-Z0-9]/g, "").toLowerCase(), i = 0, j = s.length - 1;
    
    if (s.length == 0) { return true; }
    
    while(i < j) {
        if(s[i] !== s[j]) return false;
        i++; j--;
    }
    return true;
};

ကျွန်တော်ပထမဆုံး string ကို regular expression သုံးပြီး replace လုပ်လိုက်တယ် နောက် Lowercase ပြောင်းလိုက်တယ်။ ပြီးတော့ left pointer, right pointer သုံးပြီးတော့ while loop ပတ်ပြီးတော့ palindrom ဖြစ်လားစစ်လိုက်တယ်။ ဒီနေရာမှာကျွန်တော် while loop ကိုသုံးတာက invalid ဖြစ်တဲ့ကောင်ဆိုမြန်မြန်ဆန်ဆန် false return ပြန်ရအောင်လုပ်လိုက်တာပါ။ Worst case မှာဒီကောင်လည်း O(n) ဖြစ်ပြီး While loop လည်း O(n) ဘဲဖြစ်ပါတယ်။

Time Complexity က O(n) ဖြစ်ပြီးတော့ Space လည်း O(1) ဖြစ်ပါတယ်။

Two Number Sum

မှတ်ချက် – ဒီ Post သည် Algorithm Interview Preparation အပိုင်းဆက်ဖြစ်သည်။

ကျွန်တော်ဒီနေ့ Solve လုပ်မှာကတော့ Two Number Sum Problem ဘဲဖြစ်ပါတယ်။ ဘယ်လို Solve လုပ်မလဲဆိုတာမပြောခင် ဘာကပြဿနာလဲဆိုတာကို တစ်ချက်ကြည့်လိုက်ရအောင်…

Argument အနေနှင့် Number Array List တစ်ခုပါမယ် Second Argument Target Value တစ်ခုပါမယ်။ ကျွန်တော်တို့ရေးရမယ့် Function က Array ထဲက Number နှစ်ခုပေါင်းထည့်ပြီးရတဲ့ Target Value Pair ပါတယ်ဆိုရင် true return ပြန်ရမယ်။ တကယ်လို့မပါဘူးဆိုရင် false return ပြန်ရမယ်

ဥပမာ – [3, 5, 2, -4, 8, 11], 7 ပေးတယ်ဆိုရင် ကျွန်တော်တို့က [[5, 2], [-4, 11]] ဆိုပြီးရှိတဲ့အတွက် true return ပြန်ပေးရမယ်။ ဘာလို့လည်းဆိုရင် (5 + 2) နှင့် (-4 + 11) တွေရဲ့ Total Sum က Target 7 ဖြစ်နေတာကိုး။

ပုံမှန် Brute Force Soluction

ကျွန်တော်တို့ပုံမှန်ဆိုရင်ဒါမျိုးကိုဘယ်လိုရှင်းမလဲ… number list array ကို Double Loop ပတ်ပြီးတော့ ပထမ Loop ထဲက Array Value ကို ဒုတိယ Loop နှင့် တစ်ခုချင်းဆီပေါင်းထည့်မယ်။ Target Value ရတဲ့ Pair တွေ့တယ်ဆိုရင် initial array မှာသွား assign လုပ်လိုက်မယ်။ ပိုပြီးမြင်သာအောင် အောက်က JavaScript Code ကိုတစ်ချက်ကြည့်လိုက်ရအောင်…

Two Sum Brute Force Solution

Worst Case Time and Space Complexity

ဒီ Bruce Force Solution ရဲ့ Time Complexity က O(n^2) ဖြစ်ပါတယ်။ ဘာလို့လည်းဆိုရင် ကျွန်တော်တို့ worst-Case မှာ Array ကို Double Loop ပတ်ရမှာကိုး။

Array Sort Walking Inward အသုံးပြု Solution

ဒီနည်းကတော့ Array ကို Sort လုပ်ပြီးတော့အတွင်းပိုင်းတဖြည်းဖြည်းဝင်လာပြီး Target Value ရှာတဲ့နည်း။ ဘယ်လိုအလုပ်လုပ်လဲဆိုရင် Sort လုပ်ပြီးသား Array ကို left အငယ်ဆုံးနှင့် Right အကြီးဆုံးပေါင်းပြီးတော့ target value နှင့်ညီလားဆိုပြီးကြည့်တာပါ။ တကယ်ကြီးနေတယ်ဆိုသေချာတယ် Right အကြီးဆုံးကိုလျှော့ကမယ် ထိုနည်းအတိုင်းဘဲငယ်တယ်ဆို Left အငယ်ဆုံးကို တစ်ပေါင်းပေးပြီးတော့ target value ရှိလားဆိုတာရှာတာပေါ့။

Array Sort Walking Inward Solution

ဒီ Array Sort Walking Inward Solution ရဲ့ Time Complexity ကတော့ Sorting Algorithm ပေါ်မူတည်ပါလိမ့်မယ်။ ပုံမှန် Sorting Algorithm ရဲ့ Time Complexity ကတော့ O(log n)။

Hash Table အသုံးပြု Solution

Hash Table အကြောင်းကိုအရင်ရေးပြီးမှဒီနည်းကိုဆက်ရေးမယ်။

ကြမ်းကိုးများ

How does computer work?

ကွန်ပျူတာတက္ကသိုလ်မတက်ခဲ့ရတော့ ကွန်ပျူတာတွေဘယ်လိုအလုပ်လုပ်လဲဆိုတာသေချာ Detail မသိဘူး (Computer တက္ကသိုလ်တက်မှ Abstraction တွေကိုကျော်နိုင်တာမဟုတ်ပါဘူး)။ အားလုံးက Abstraction တွေဘဲဖြစ်နေတယ်။ ဘာလို့လည်းတော့မသိဘူး ဒီ Abstraction တွေကို ဘယ်လို (How) အလုပ်လုပ်လဲဆိုတာကို Programmer စလုပ်ကာစက မစဥ်းစားဖြစ်ဘူး။ High-Level Over View တွေကိုဘဲလေ့လာဖြစ်တယ်။ အခုနောက်ပိုင်း Computer Science နှင့် Math ကို ကိုယ့်ဘာသာ Online က Self Study လုပ်တဲ့အခါမှ Abstraction တို့ How thing work တို့ဆိုတာတွေတွေ့လာရပြီး ဘယ်လိုအရေးကြီးတယ်ဆိုတာ ပိုပိုပြီးသိလာတယ်။

အခုကျွန်တော်တို့သုံးနေတဲ့ Computer ဆိုတာကအများကြီးလုပ်နိုင်တယ်… Program ရေးတာကမစ YouTube တို့ရုပ်ရှင်တို့ကြည့်တာတွေအဆုံးပါဘဲ။ ကျွန်တော်တို့ Laptop ကိုနမူနာကြည့်လိုက်ရအောင်… သူ့ကိုအားသွင်းတယ်… power button နှိပ်လိုက်ရင် OS တက်လာတယ်… ခုနကပြောခဲ့တဲ့ example တွေအကုန်လုံးလုပ်နိုင်သွားတယ်။ ကျွန်တော်အခုပေးလိုက်တဲ့ Example တွေတော်တော်များများက High-Level Overview လို့ပြောနိုင်တယ်။ တကယ်ကို Deep Down သိချင်တယ်ဆိုရင်တော့ အောက်ဖော်ပြပါ Crash Course Computer Science YouTube Video Playlist ကိုကြည့်ကြည့်လိုက်ပါ။

Crash Course Computer Science

ဒီ Playlist ကရှည်တယ်လို့ပြောလို့ရပါတယ်။ ခွဲခွဲပြီးကြည့်မှအဆင်ပြေပါလိမ့်မယ်။ အစပိုင်းမှာ computer တွေဘယ်လိုစဖြစ်ပေါ်တယ်ကစပြီး Electronic ကနေ Binary Number System တွေအကြောင်း…. အဲ့ကတစ်ဆင့် ALU တို့ Logic Gate တွေအကြောင်း… နောက်တစ်ဆင့် Storage RAM (Random Access Memory)၊ Sotrage၊ Operating System၊ Programming Language၊ Software Engineering တို့ကစပြီး ယနေ့ခေတ် Computer Science နှင့်ပါတ်သတ်တာတွေပါရှင်းလင်းထားတာက Animation လေးတွေနှင့်အတော်ကိုစိတ်ဝင်စားဖို့ကောင်းပါတယ်။ ဒီ Course ကိုတက်ပြီးတကယ်နားလည်တယ်ဆိုရင် Abstraction တွေကို Pass ဖြစ်ပြီးတော့ How Thing Work ကိုအနည်းနှင့်အများနားလည်မယ်ဆိုတာတော့အသေအချာပါဘဲ။

ဒီ Post မှာကျွန်တော် Abstraction ဆိုပြီးခဏခဏသုံးသွားတယ်။ မြန်မာလိုဘာသာပြန်ဖို့ကြိုးစားပေမယ့် တိုတိုနှင့်လိုရင်းကိုမရောက်ဘူး abstraction ကိုမြန်မာလို define လုပ်တာနှင့် Post တစ်ခုလောက်ဖြစ်သွားလိမ့်မယ်။ ဒါကြောင့် Abstraction ကိုသေချာရှင်းပြထားတဲ့ Video File ကိုရှာပြီးအောက်မှာပြန်ထည့်ပေးထားတယ်။

Abstraction ဆိုတာဘာလဲ Professor David J. Malan မှရှင်းပြခြင်း

မှတ်ချက်။ ဒီ YouTube Playlist လိုမြန်မာလို Animation လေးတွေနှင့်တစ်နေ့နေ့တော့ရှင်းပြနိုင်ဖို့ကြိုးစားပါဦးမယ်။

Big O Notation ဆိုတာဘာလဲ

Computer ကျောင်းဆင်းတွေဆိုရင်တော့ Big O ဆိုတာဘာလဲသိကြမယ်ထင်တယ်။ ကျွန်တော်တော့ ကိုယ့်ဘာသာ Algorithm Courses တွေလိုက်တက်ရင်းဟိုဖတ်ဒီဖတ်ဖတ်ရင်းမှ Big O ဆိုတာကြားဖူးပြီးလေ့လာဖြစ်တာပါ။ ကျွန်တော့်အတွက်တော့စလုပ်ခါစမှာ သိပ်မလွယ်ဘူးလို့ခံစားရပါတယ်။ ကျွန်တော်တက်နိုင်သလောက် အလွယ်ကူဆုံးဖြစ်အောင်တော့ကြိုးစားပြီး References တွေယူပြီးရှင်းပြထားပေးပါတယ်။

Big O ဆိုတာဘာလဲကအရင်စလိုက်ကြရအောင်။ ရိုးရိုးရှင်းရှင်းနားလည်အောင်ပြောရမယ်ဆိုရင် Big O ဆိုတာ Programmer အချင်း Algorithm တွေအကြောင်းပြောတဲ့နေရာမှာသုံးတဲ့စကားဖြစ်ပါတယ်။ Algorithm ထပ်ရှင်းရမယ်ဆိုရင် ကျွန်တော်တို့ရေးနေတဲ့ Function တွေဟာ Algorithm တွေလို့အကြမ်းဖျင်းမှတ်သားနိုင်ပါတယ်။ အဲ့တော့ Big O ဆိုတာ ကျွန်တော်တို့ရေးသားနေတဲ့ Program ထဲက Function တွေက input size ပေါ်မူတည်ပြီးတော့နှေးတယ်မြန်တယ်ဆိုတာတွေကိုခွဲခြားပေးတဲ့နည်းလို့ သတ်မှတ်နိုင်ပါတယ်။ နောက် Big O ကိုတစ်နည်း Asymptotic Notation လို့ခေါ်ပါတယ်။

မှတ်ချက်။ ကျွန်တော်ဒီ Blog Post မှာတော့ Big O ရဲ့ Mathematical Formal Definition ကိုရှုပ်သွားမှာစိုးလို့မရှင်းပြတော့ပါဘူး။ နောက်ထက် Post တစ်ခုလုပ်ပြီးရှင်းပြဖို့ကြိုးစားပါ့မယ်။

O(1) time (or “constant time”)

အောက်က Function တစ်ခုနှင့်စမ်းလိုက်ကြရအောင်…

function printFirstItem(items) {
  console.log(items[0]);
}

အထက်ဖော်ပြပါ Function ကိုတစ်ချက်ကြည့်မယ်ဆိုရင် items ထဲက values တွေဘယ်လောက်ဘဲတိုးလာတိုးလာ ဒီ Function ရဲ့ complexity က O(1) ဘဲဖြစ်ပါတယ်။

O(1) function

အထက်ဖော်ပြပါ ပုံဟာ O(1) run time ဖြစ်တဲ့အတွက်ဘယ်လောက်ဘဲ Value တွေတိုးလာတိုးလာ အချိန်ကြာတာကတော့တူတူ (“constant time”) ဘဲဖြစ်နေပါလိမ့်မယ်။ O(1) constant time ဖြစ်တဲ့ Function ရဲ့ running time ကတော့ဘယ်လိုပြောရမလဲ the best ပေါ့နော် 🤣။

O(n) time (or “linear time”)

function printAllItems(items) {
  items.forEach(item => {
    console.log(item);
  });
}

ကျွန်တော်တို့အထက်ဖော်ပြပါ Code block ကိုကြည့်မယ်ဆိုရင် ဒီ Function ရဲ့ Run Time က O(n) (linear time) ပါ။ ဒီနေရာမှာ items ထဲက value တိုးလာတာနှင့်အမျှ Function ထဲက Process လုပ်တာကလည်းတဖြည်းဖြည်းတိုးလာမှာဖြစ်တဲ့အတွက် O(n) (linear time) ပေါ့။ သူ့ရဲ့ Run time က Big O(n) လောက်မမြန်တာတော့သေချာတယ်။ O(1) က the best ဆို O(n) က Good လို့ပြောရမယ်ထင်တယ်။

O(n) runtime

O(n^2) time (“quadratic time”)

function printAllPossibleOrderedPairs(items) {
  items.forEach(firstItem => {
    items.forEach(secondItem => {
      console.log(firstItem, secondItem);
    });
  });
}

အထက်ဖော်ပြပါ Function ကိုကြည့်မယ်ဆိုရင် nested loop. Loop ထဲမှာ Loop ပြန်ပတ်ထားတယ်။ ကျွန်တော်တို့ items ဆိုတဲ့ array ထဲမှာ n items ရှိတယ်ဆိုရင် အပြင်ဘက်က Loop က n time နောက်အတွင်းပိုင်း loop က n time ကြာမယ် စုစုပေါင်းဒီ Function ရဲ့ Running time က O(n^2)။ O(n^2) က O(1) တို့ O(n) တို့နှင့်ယှဥ်ရင်တော့ Shitty ဖြစ်တယ်လို့ပြောရမှာဘဲ 🤣။ အောက်ဖော်ပြပါ O(n^2), O(n), O(1) Running Time နှိုင်းယှဥ်ချက် Graph ကိုတစ်ချက်ကြည့်ကြည့်လိုက်ရအောင်။

O(n^2), O(n), O(1) Running Time နှိုင်းယှဥ်ချက် Graph

အခုကျွန်တော်ရှင်းပြဖို့ကျန်နေသေးတာကတော့ O(log n) ဘဲ။ သူကဒီတိုင်းရှင်းပြရတာနည်းနည်းရှုပ်လို့ Merge Sort တို့ Binary Search တို့အကြောင်းပြောပြမှသူကိုအသေးစိတ်ပြန်ရှင်းပြတော့မယ်။

ဒီလောက်ဆိုရင် Big O ဆိုတာဘာလဲသိသွားလောက်ပါပြီ။ အခုဆို ကိုယ်ရေးထားတဲ့ Code ထဲမှာ O(n^2) Nested loop တွေများပါမလား… O(n) ရအောင်လုပ်လို့ရမလား… ဒါမျိုးလေးတွေတွေးနိုင်သွားပါပြီ။ နောက်ပိုင်း Algorithm တွေ Data Structure တွေရဲ့ Running Time အကြောင်းပြောတဲ့အခါမှာလည်းအသုံးပြုသွားနိုင်ပြီလို့ထင်ပါတယ် 😎။

ကြမ်းကိုးများ

Asymptotic Notation Best explanation

Hexadecimal number system ဆိုတာဘာလဲ

ကျွန်တော်ပြီးခဲ့တဲ့ Post မှာ Binary Number System ဆိုတာဘာလဲဆိုပြီးရေးခဲ့တယ်။ ကျွန်တော်တို့ပုံမှန်သုံးနေတဲ့ 0 to 9 က Base 10, Binary Number System က Base 2၊ အခုကျွန်တော်ဒီနေ့ပြောမယ့် Hexadecimal number system ကတော့ base 16 ဖြစ်ပါတယ်။

ကျွန်တော်တို့ပုံမှန် Base 10 က

0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9 = Base 10

အခု Base 16 မှာဆိုရင်

0 1 2 3 4 5 6 7 8 9 A B  C  D  E  F
0 1 2 3 4 5 6 7 8 9 0 11 12 13 14 15 = Base 16

ဆိုပြီးစုစုပေါင်း 16 လုံးရှိမှာဖြစ်ပါတယ်။

ကျွန်တော်တို့ဒီနေရာမှာပြောစရာရှိတာက ဟုတ်ပါပြီ A to F က Number တွေမဟုတ်ဘူးလေဆိုပြီးမေးမယ့်သူတွေရှိမှာပါ… ဒီနေရာမှန်တစ်ချက်ကျွန်တော်တို့ပြန်စဥ်းစားရမှာက 0 to 9 ဆိုတာကလည်းအမှတ်လက္ခဏာတွေဘဲမဟုတ်ဘူးလားဆိုတာပါဘဲ၊ အဲ့လိုတွေးလိုက်ရင် A to F က Number မဟုတ်တာကအဆင်ပြေသွားပြီ။ ပုံမှန်ဆို A က 13 ဖြစ်နေမှာ… အခု Base 16 မှာကြတော့ A အဲ့ဒါကြောင့် A လို့ဘဲခေါ်ရင်အဆင်ပြေမယ်ထင်တယ်။ ကျွန်တော်တို့ပုံမှန်တွေးတာတွေဖျောက်လိုက် Base 16 Number System အတိုင်းဘဲသွားလိုက် ဒါဆိုအဆင်ပြေသွားပြီ။

ကျွန်တော် Binary Number System အကြောင်းရေးတုန်းက Base 10 – 125 က Binary Number မှာဆို 1111101 ရတယ်ဆိုပြီးပြဖူးတယ်။ အခု 125 က Hexadecimal number မှာဘာရမလဲဆိုတာတစ်ချက်ကြည့်လိုက်ရအောင်…

Base 16 မှာ Base 10 Number 125 က 7D ဆိုပြီးရပါတယ်။ ဘယ်လိုရတာလဲတစ်ချက်အောက်မှာကြည့်လိုက်ရအောင်…

0 1 2 3 4 5 6 7 8 9 A  B  C  D  E  F
                    10 11 12 13 14 15

Base 10 Number 125 is equal to 7D of Base 16.

125 = 7 D
= (7 x 16) + (D x 1)
= 112 + (D=13 x 1)
= 125
Base 16 7D is equal to Base 10 125

ကျွန်တော်ဒီတိုင်းပုံမှန်စာနှင့်ဘဲရှင်းပြမလို့နားလည်ဘို့မလွယ်ဘူးထင်လို့ ဘောပင်နှင့်စာရွက်ပေါ်ရေးပြီးတော့နည်းနည်းရှင်းပြထားတယ်။ အဲ့ဒါကိုတစ်ချက်ပြန်ရှင်းလိုက်ရအောင်… 7D မှာ D က 1 နေရာမှာရှိတယ် base 16 ရဲ့ power ကဒီနေရာမှာ 0 ဖြစ်တယ်ဆိုတာအရင် Post မှာရှင်းပြပြီးလို့နားလည်မယ်ထင်ပါတယ်။ ဒါကြောင့် (D x 1) ဖြစ်သွားတယ်။ နောက် D ရဲ့တန်ဖို့းက Base 16 မှာ 13။ 7 ကြတော့ base 16 power က 1 ဖြစ်တယ်။ နောက် base 16 ဖြစ်တဲ့အတွက် 16 နှင့်ဆတိုးဖြစ်သွားတဲ့အတွက် Base က 16။

ဒီလောက်ဆိုလျှင် Hexadecimal Number ဘယ်လိုအလုပ်လုပ်လဲဆိုတာသိလောက်ပြီထင်ပါတယ်။ ကျွန်တော်ရှင်းပြတာတွေနားမလည်သေးရင် Comment မှာမေးနိုင်ပါတယ်။ သို့မဟုတ်ကြမ်းကိုး မှာကိုယ်တိုင်သွားရောက်လေ့လာနိုင်ပါတယ်။

ကြမ်းကိုး