မင်္ဂလာပါ!

လှိုက်လှဲစွာကြိုဆိုပါသည်။ ယခု ပထမဆုံးအကြိမ် ရောက်ဖူးခြင်းဖြစ်ပါသလား? ဝင်ရောက် ဆွေးနွေး မေးမြန်းလိုပါလျှင် အောက်တွင်ဖော်ပြထားသော button များမှတဆင့် ဝင်ရောက် ဆွေးနွေးနိုင်သကဲ့သို့ အဖွဲ့ဝင်အသစ်အနေဖြင့်လည်း လျှောက်ထားနိုင်ပါတယ်။

MYSTERY ZILLION တွင် English သို့မဟုတ် Unicode ဖြင့်သာ အသုံးပြုခွင့်ရှိသည်။ ဇော်ဂျီ ၊ ဧရာ စသည်တို့ကို အသုံးပြုခွင့် မရှိ။ Unicode fonts များမှာ Mon3,Yunghkio, Myanamr3 စသည်များ အသုံးပြုနိုင်သည်။ Unicode Guide ကို ဒီမှာ Download ချပါ။ Zawgyi to Unicode Converter
Don't share ebook or software if nobody request. You can find free book websites on here. We are welcome for discussion or asking question instead.

Evolution of Programming Knowledge Level

edited April 2011 in My Article
တကယ်တော့ ပရိုဂရမ်ရေးတယ်ဆိုတာ လွယ်ပါတယ် သက်ဆိုင်ရာ Language ရဲ့ Syntax ကိုသိတာနဲ့ ရေးလို့ရပါပြီ တကယ်တည်ဆောက်ဖို့ လိုအပ်တာက ကိုယ်ပိုင်ဆိုင်တဲ့ Knowledge ပမာဏပါ။ ပရိုဂရမ်ရေးဆိုရင် များများရေးကြည့် များများတတ်တယ်လို့ ပြောတတ်ကြတယ် တစ်ကယ်တော့ အမြဲမမှန်ပါဘူး များများရေးတော့ Syntax ကိုပိုသိလာတယ် အဲဒါကြောင့် ရေးရလွယ်လာတယ် အဲဒါကိုခေါ်တာပါ။ ကိုယ်တိုင်တည်ဆောက်လို့မရတဲ့ Knowledge တွေအများကြီးရှိပါတယ် စပြီးလေ့လာကာစ လူတစ်ယောက်ကို if ကိုဘယ်လိုရေး for နဲ့ while ကိုဘယ်လိုသုံးဆိုပြီး အသုံးတတ်သွားအောင် လေ့ကျင့်ခိုင်းလို့ရပါတယ် ဒါပေမယ့် အဲဒါတွေထက် အဆင့်မြင့်တဲ့ Algorithm တွေကတော့ သက်ဆိုင်ရာ ဘာသာရပ်တွေကို လေ့လာမှသာ သိနိုင်ပါတယ် အရာအားလုံး ကိုယ်တိုင်တည်ဆောက်ယူဖို့ အချိန်မရှိသလို ဖြစ်လည်းမဖြစ်နိုင်ပါဘူး။ ပရိုဂရမ်စပြီးရေးတဲ့လူတိုင်း မြင်ဖူးတဲ့ Factorial ရှာတဲ့ ပရိုဂရမ်တစ်ခုကို မှတ်မိသလောက် ပြောင်းရေးထားပါတယ်။

<h4>Algorithm 1</h4>
<pre lang="python">
#Prerequisites:
#What is factorial?
#!/usr/bin/python
def factorial1(num):
fact = 1
for x in range(2, num+1):
fact = fact * x
return fact
</pre>

Algorithm 1 ကတော့အရှင်းလင်းဆုံးပါ ပရိုဂရမ်ရေးတာ စပြီးသင်တဲ့ ကျောင်းသားတွေကို Factorial ဆိုတာဘယ်လိုဆိုတာ ရှင်းပြပြီးတော့ တွက်တဲ့ပရိုဂရမ်ကို ရေးခိုင်းလေ့ရှိတယ် အခြေခံအနေနဲ့ operator, assign, loop အဲဒါတွေသိရင် ရေးလို့ရပါတယ် ရေးတဲ့လူဟာကိုယ်တိုင်ပဲ Logic ကို တည်ဆောက်ယူလို့ရပါတယ် အခြားလိုအပ်ချက်တွေမရှိပါဘူး။

<h4>Algorithm 2</h4>
<pre lang="python">
#Prerequisites:
#1) Fundamental Data Structure
#2) Recursive Algorithm
#!/usr/bin/python
def factorial2(num):
if num>2:
return num * factorial2(num-1)
return num
</pre>

Algorithm 2 ကတော့ Factorial ဆိုတာဘာလဲသိရုံနဲ့ မလုံလောက်တော့ပါဘူး Algorithm ရေးပုံအမျိုးမျိုးနဲ့ သက်ဆိုင်တဲ့အရာတွေကို သိဖို့လိုအပ်ပါတယ်။ Recursive Algorithm Structure ဟာ အရေးပါပါတယ် အခြားခက်ခဲတဲ့ Algorithm တွေရဲ့အခြေခံလို့ ပြောလို့ရနိုင်ပါတယ်။ ဒီနေရာမှာ Recursive Algorithm အကြောင်းသိဖို့အတွက် သက်ဆိုင်ရာ ဘာသာရပ်ကိုမဖတ်ပဲ ကိုယ်တိုင်ပရိုဂရမ်ရေးရင်း တွေ့ရှိဖို့ဆိုတာမဖြစ်နိုင်ပါဘူး အဲဒါကြောင့် သက်ဆိုင်ရာ Fundamental Data Structure ဘာသာတွေကို ဖတ်ဖို့လိုအပ်ပါလိမ့်မယ်။

<h4>Algorithm 3</h4>
<pre lang="python">
#Prerequisites:
#1) Need to read the manuals of specific language
#!/usr/bin/python
import math

def factorial3(num):
return math.factorial(num)
</pre>

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

မှတ်ချက်များ

  • Administrators
    <h4>Algorithm 4</h4>
    <pre lang="python">
    #Prerequisites:
    #1) Divide and Conquer
    #2) Map and Reduce
    #3) Language specific reduce method
    #!/usr/bin/python
    def factorial4(num):
    return reduce(long.__mul__, [long(x) for x in range(2, num + 1)])
    </pre>

    Algorithm 4 ကတော့ အဆင့်မြင့် Algorithm Structure တစ်ခုဖြစ်တဲ့ Divide and Conquer ကိုအခြေခံပါတယ်။ Divide and Conquer Algorithm တိုင်းမှာ Recursive ပါဝင်တဲ့အတွက် Recursive ကိုနားလည်ရပါမယ်။ Distirbuted Algorithm တစ်ခုဖြစ်တဲ့ Map and Reduce သဘောတရားကိုလည်း အသုံးပြုထားပါတယ် ဒီနေရာမှာ Distirbuted မဟုတ်ပဲ Serial ဖြစ်နေတာရယ် ရှုပ်ထွေးတဲ့ တွက်ချက်မှု့မပါတဲ့အတွက် Map လုပ်ဖို့မလိုအပ်လို့ Reduce သာအသုံးပြုထားပါတယ်။ ဒီနေရာမှာလည်း Map and Reduce ကိုအသုံးပြုပေမယ် အရာအားလုံး ကိုယ်တိုင်မရေးသားပါဘူး သက်ဆိုင်ရာ Language ကထောက်ပံ့ပေးထားတဲ့ Map and Reduce ကိုသင့်လျော်သလို အသုံးပြုထားပါတယ်။

    <h4>Algorithm 5</h4>
    <pre lang="python">
    #Prerequisites:
    #1) Divide and Conquer
    #2) Map and Reduce
    #3) Processor Architecture
    #4) Multiprocessing
    #5) Thread Pool
    #6) Language specific multiprocess map
    #!/usr/bin/python
    import multiprocessing

    def mul_x2y((x, y)):
    if(x!=y):
    return x * mul_x2y((x+1,y))
    else:
    return x

    def factorial5(num):
    cpu_count = multiprocessing.cpu_count()
    job_list = [(x,x+cpu_count-1) for x in range(1, (num/cpu_count)*cpu_count, cpu_count)]
    if num%cpu_count>0:
    job_list = job_list + [((num/cpu_count)*cpu_count+1,num)]
    pool = multiprocessing.Pool(cpu_count)
    return reduce(long.__mul__, [long(x) for x in pool.map(mul_x2y,job_list)])
    </pre>

    Algorithm 5 ကတော့ Algorithm 4 ကိုအဆင့်မြင့်ထားတာပါ Algorithm 4 မှာ Map and Reduce ကိုသုံးတယ်ဆိုပေမယ့် အပြည့်အဝအသုံးမချသလို Parallel Processing အတွက်လည်း မရည်ရွယ်ထားပါဘူး အခုအချိန်မှာ Computer တွေဟာ အများအားဖြင့် Multi-core, Multi-proecessor တွေနဲ့ဖြစ်လာလို့ အဲဒါတွေကိုလည်း အကျိုးရှိရှိ အသုံးချဖို့လိုပါတယ်။ Algorithm 5 မှာတော့ Processor တစ်လုံးချင်းစီအတွက် အလုပ်ကိုခွဲဝေပြီး Map လုပ်ပြီးတွက်ချက်လိုက်ပါတယ် ပြန်လာတဲ့ Partial Result တွေကို Reduce လုပ်ခြင်းအားဖြင့် နောက်ဆုံးအဖြေကို တွက်ယူလိုက်ပါတယ်။
  • Administrators
    Algorithm 5 ကိုလည်းထပ်ပြီးတော့ အဆင့်မြင့်မယ်ဆိုရင် ရနိုင်ပါသေးတယ် Algorithm 5 ဟာ Multiprocessing အတွက်ရည်ရွယ်ပေမယ့် Computer တစ်လုံးတည်းအတွက်ပဲ ရည်ရွယ်ထားပါတယ် အကယ်၍ Computer တစ်လုံးထက်ပိုခဲ့မယ်ဆိုရင် Distributed Processing လုပ်လို့ရပါတယ် အဲဒါကြောင့် ကိုယ်ပိုင်ဆိုင်တဲ့ Knowledge ဘယ်လောက်ရှိမလဲဟာ အင်မတန်အရေးကြီးပါတယ် ဒါကြောင့် သက်ဆိုင်ရာ ဘာသာရပ်တွေကို လေ့လာနေဖို့လိုအပ်ပါတယ်။ အဲဒါတွေကိုအခြေခံပြီး သင့်လျော်တဲ့နေရာတွေမှာ အသုံးချယူရတာပါ ခက်ခဲတဲ့ Algorithm ဟာလည်း နေရာတိုင်းမှာ သင့်လျော်ချင်မှ သင့်လျော်ပါတယ် အလွယ်ဆုံး Algorithm ဟာလည်း အကောင်းဆုံးဖြစ်တတ်ပါတယ်။ အောက်မှာပြထားတဲ့ Performance Results တွေကိုကြည့်ပါ။
    <a href="http://blog.calmhill.info/wp-content/uploads/2011/04/1k_to_9k.png"><img src="http://blog.calmhill.info/wp-content/uploads/2011/04/1k_to_9k-300x179.png"; alt="1000 to 9000" title="1000 to 9000" width="300" height="179" class="aligncenter size-medium wp-image-477" /></a>
    Algorithm ငါးခုလုံးဟာ ပုံမှန်အားဖြင့် ကောင်းကောင်းအလုပ်လုပ်ပါတယ် ကိန်းဂဏန်းသေးရင် တွက်ချက်ချိန်ကို မှန်းလို့မရပါဘူး အဲဒါကြောင့် ၁၀၀၀ ကနေ ၉၀၀၀ အထိကိန်းဂဏန်းတွေကို Algorithm တစ်ခုစီနဲ့တွက်ချက်ပြီး ကြာချိန်ကိုတိုင်းတာလိုက်ပါတယ်။ အဖြေတွေကိုကြည့်လိုက်တော့ ခက်ခက်ခဲခဲရေးထားတဲ့ Algorithm 5 ဟာအကြာဆုံးဖြစ်နေပြီး Recursive သုံးထားတဲ့ Algorithm 2 ဟာဒုတိယ အနှေးဆုံးဖြစ်ပါတယ်။ Built-in Function ကိုယူသုံးထားတဲ့ Algorithm 3 ဟာအမြန်ဆုံးဖြစ်နေပြီး Algorithm 1 and Algorithm 4 ကတော့ တူညီသလောက်ဖြစ်ပါတယ်။
    <a href="http://blog.calmhill.info/wp-content/uploads/2011/04/10k_to_90k.png"><img src="http://blog.calmhill.info/wp-content/uploads/2011/04/10k_to_90k-300x179.png"; alt="10000 to 90000" title="10000 to 90000" width="300" height="179" class="aligncenter size-medium wp-image-478" /></a>
    နောက်တစ်ြကိမ် စမ်းသပ်တဲ့အနေနဲ့ ၁၀၀၀၀ ကနေ ၉၀၀၀၀ အထိကိန်းတွေကို တစ်ခေါက်တွက်ချက်ပြီး ကြာချိန်တွေကိုပြန်ပြီး တိုင်းတာကြည့်ပါတယ်။ ဒီအချိန်မှာတော့ ရလဒ်တွေဟာ ပထမတိုင်းတာချက်နဲ့ ကွဲပြားသွားပါတယ်။ ပထမတိုင်းတာချက်မှာ အနှေးဆုံးဖြစ်တဲ့ Algorithm 5 ဟာကိန်းဂဏန်းကြီးလာတာနဲ့အမျှ အခြားသော Algorithm တွေထက် ကြာချိန်သိသိသာသာ လျော့နည်းသွားတာ တွေ့ရပါတယ်။ ပထမအကြိမ်မှာ ကြာချိန်အနည်းဆုံးဖြစ်တဲ့ Algorithm 3 ဟာ ကိန်းဂဏန်းကြီးလာတာနဲ့အမျှ ကြာမြင့်ချိန်အများဆုံး Algorithm ဖြစ်လာပါတယ်။ Algorithm 1 and Algorithm 4 ကတော့ ပထမတိုင်းတာချက်အတိုင်းပဲ ကွာခြားချက်သိပ်များပဲ တူညီသလောက်ရှိပါတယ်။ ဒီတစ်ြကိမ်မှာတော့ Algorithm 2 ဟာ Stack Space မလုံလောက်တဲ့အတွက် တွက်ချက်ခြင်း မပြုနိုင်တော့ပါဘူး။

    စမ်းသပ်ချက်တွေက 4 Core CPU and 6 GB RAM ရှိတဲ့စက်မှာ စမ်းသပ်ထားတာပါ အခြားစက်မှာဆိုရင် အချိန်ကွာခြားမှု့ရှိနိုင်ပါတယ်။ အပေါ်မှာပြထားတဲ့ တိုင်းတာချက်တွေကို နမူနာကြည့်ချင်းအားဖြင့် Algorithm ခက်ခဲတိုင်းလည်း ထွက်လာတဲ့အဖြေဟာ တွက်ချက်မယ့် အခြေအနေများအပေါ်မှာ မှိခိုပါတယ်။ နမူနာအားဖြင့် Algorithm 5 ဟာကောင်းပေမယ့် ကိန်းဂဏန်းငယ်တဲ့အချိန်မှာ Processor တွေကိုအလုပ်ခွဲဝေတဲ့ အလုပ်တွေက တွက်ချက်ချိန်ထက် ပိုပြီးကြာမြင့်တဲ့အတွက် အခြားရိုးစင်းတဲ့ Algorithm တွေထက်နှေးသွားပါတယ် ဒါပေမယ့် ကိန်းဂဏန်းကြီးလာတာနဲ့အမျှ ရလဒ်တွေဟာ ကောင်းလာတာကို တွေ့နိုင်ပါတယ်။ ဒီနေရာမှာ Recursive ဟာ Logic မှန်ပေမယ့် Language ရဲ့ကန့်သတ်ချက်ကြောင့် အလုပ်မလုပ်နိုင်တာတွေ တွေ့ရပါတယ်။

    နှိုင်းယှဉ်ပြထားတွေကို နောက်ဆုံးချုပ်ပြောရရင် Knowledge Building အတွက်ကတော့ သက်ဆိုင်ရာ ဘာသာရပ်တွေကို လေ့လာရပါလိမ့်မယ် စာမဖတ်ပဲတော့ ဘာမှဖြစ်မလာနိုင်ပါဘူး နောက်ထပ်လေ့လာဖို့ အခွင့်အရေးဆိုတာက ကျောင်းတက်နေတုံးမှာ အများဆုံးရနိုင်ပါတယ် ကျောင်းတွေမှာပဲ သင်လို့ရနိုင်တဲ့ ဘာသာရပ်တွေ အများကြီးရှိတယ် ကျောင်းမှာသင်သမျှ ကိုယ့်အတွက် အသုံးမတည့်ပေမယ့် တကယ်လေ့လာခဲ့ရင် တစ်သက်လုံးအကျိုးရှိနိုင်မယ့် ဘာသာရပ်တွေအများကြီးပါ။ ပိုင်ဆိုင်လာတဲ့ Knowledge တွေကို သင့်လျော်ရာကို ဘယ်လိုသုံးမလဲဆိုတာကတော့ ကိုယ်ဘယ်လောက် အသုံးချဖို့ကြိုးစားဖူးသလဲဆိုတဲ့ အမှားတွေ အများကြီးဖြစ်ခဲ့တဲ့ အတွေ့အကြုံက အလိုလိုသင်သွားပါလိမ့်မယ်။
  • Moderators
    very nice ! <br>i love it <br>I like to read you post again .   anyway i just know algorithm 1 to 3  :D  <br>
  • Administrators
    MapReduce ဆိုတာက တကယ်တော့ အယူအဆတစ်ခုပါ Algorithm လည်းမဟုတ်ပါဘူး အလုပ်တွေကို သက်ဆိုင်ရာ ကွန်ပျူတာ ဒါမှမဟုတ် Processor တွေဆီကိုဘယ်လိုခွဲမလဲ ပြန်ထွက်လာတဲ့ တစ်စိတ်တစ်ဒေသ တွက်ချက်ပြီးသား အဖြေတွေကိုဘယ်လို အပြီးသတ်ပေါင်းစည်းမလဲဆိုတာ အခြေခံယူဆချက်ပါ အဲဒါနားလည်ရင်လွယ်ပါတယ်။ ကုဒ်ကနည်းနည်းရှုပ်နေနိုင်တယ် Python နဲ့ဘယ်တုံးကမှမရေးဘူး တစ်ခြားဟာနဲ့ရေးရင် ရှည်နေလို့ Manual ဖတ်ပြီးရေးထားတာ နားလည်ရင် ဒီထက်တိုအောင်လည်း ရေးလို့ရချင်ရမယ်။
  • Administrators
    Map Reduce က ေနာက်ပိုင်း NoSQL တွေမှာ သုံးလာတာကို တွေ့ရတယ်။ အဲဒီ map reduce နဲ့ အခု code မှာ ရေးထားတဲ့ ဟာနဲ့ က အတူတူပဲလား ? mongodb ရဲ့ map reduce ကို ဖတ်ပေမယ့် ကောင်းကောင်းတော့ နားမလည်သေးဘူး။
  • Administrators
    Map Reduce ဆိုတာက ဘယ်မှဖြစ်ဖြစ်အတူတူပါပဲ Map Reduce ဘယ်လိုလုပ်မယ်ဆိုတဲ့ အယူအဆပဲအရေးကြီးပါတယ် ကျန်တာကတော့ ကိုယ်သုံးမယ့် Tools ရဲ့ Support တွေဆိုတော့ အနည်းနဲ့အများ သုံးတာတော့ကွဲမှာပေါ့။ mongodb ဆိုတာ ကိုယ်လည်းမသိပါဘူး ဒါပေမယ့်သွားကြည့်လိုက်တယ် သူ့လည်းအတူတူပါပဲ Map and Reduce အတွက် Function တစ်ခုစီခွဲရေးပြီးတော့ ထည့်ပေးလိုက်ရုံပါပဲ။<br><br>တကယ်တော့ Map and Reduce ဆိုတာက Function တစ်ခုခေါ်သုံးတာမဟုတ်ဘူး အခုပြောနေတာတွေက ကိုယ်ဒီဇိုင်းလုပ်ထားတဲ့ Map and Reduce ကို Support လုပ်ထားတဲ့ Tools ထဲမှာထည့်ပေးလိုက်တဲ့ အဆင့်ပဲရှိပါတယ်။ တကယ်အရေးကြီးတာက How to chunk and map(process) the data? And how to reduce(summarize data from partial result)? အဲဒီ့ Knowledge တွေကသာအရေးကြီးပါတယ်။ အဲဒါတွေအတွက်က Map and Reduce ကိုဖတ်နေလို့မရပါဘူး Parallel Processing Algorithm တွေကိုနားလည်မှသာ သင့်လျော်သလို ဒီဇိုင်းလုပ်နိုင်ပါလိမ့်မယ်။ တကယ်တော့ Map and Reduce ဆိုတာအသစ်မဟုတ်ဘူး Distributed ဖြစ်သွားတာ တစ်ခုပါပဲ Idea ကအသစ်မဟုတ်ဘူး လွန်ခဲ့သောနှစ်ပေါင်းများစွာက Multiple Processor တွေအတွက်သုံးတဲ့ Algorithm တွေမှာဒါတွေရှိခဲ့ပြီးသားပါ။<br><br>အောက်မှာပြထားတဲ့ နမူနာကိုကြည့်ပါ သူကတော့ Distributed အတွက် Hadoop ကိုသုံးလိုက်တယ် အဲဒါကြောင့် ကွန်ပျူတာဘယ်နှစ်လုံးရှိသလဲ ဘယ်နားမှာရှိသလဲ Data တွေဘယ်နားမှာထားသလဲ အဲဒါတွေကိုပူစရာမလိုပါဘူး Hadoop ရဲ့ Infrastructure ကတာဝန်ယူပါတယ် အဲဒါကြောင့် Tools အပေါ်မှာမူတည်ပါတယ် Python နဲ့ရေးလို့ အပေါ်ကလိုရေးတယ်လို့ မထင်စေချင်ဘူး။<br><br><a href="http://www.michael-noll.com/tutorials/writing-an-hadoop-mapreduce-program-in-python/">Writing An Hadoop MapReduce Program In Python</a><br>
Sign In or Register to comment.