စမတ်ပရိုဂရမ်မာတွေအတွက် ဘာကြောင့် Go Design က မကောင်းတာလဲ။

ပြီးခဲ့သောလများအတွင်း ကျွန်ုပ်သည် Go ကို အကောင်အထည်ဖော်ရန်အတွက် အသုံးပြုနေပါသည်။ Concept ကိုသက်သေပြ (အနီးစပ်ဆုံး: code to test the functionality of idea) မိမိအားလပ်ချိန်များတွင် တစ်စိတ်တစ်ပိုင်း ပရိုဂရမ်းမင်းဘာသာစကားကို ကိုယ်တိုင်လေ့လာပါ။ ပရိုဂရမ်များကိုယ်တိုင်က အလွန်ရိုးရှင်းပြီး ဤဆောင်းပါး၏ရည်ရွယ်ချက်မဟုတ်သော်လည်း Go ကိုယ်တိုင်အသုံးပြုခြင်းအတွေ့အကြုံသည် ၎င်းနှင့်ပတ်သက်သည့် စကားလုံးအနည်းငယ်နှင့် ထိုက်တန်ပါသည်။ သွားပါမည်ဟု ကတိပြုပါသည် (အနီးစပ်ဆုံး: 2015 တွင်ရေးထားသောဆောင်းပါး) လေးနက်သောအရွယ်မှာသုံးနိုင်သောကုဒ်အတွက်ရေပန်းစားသောဘာသာစကားတစ်ခု။ ၎င်းဘာသာစကားကို တက်ကြွစွာအသုံးပြုနေသည့် Google မှ ဖန်တီးခဲ့ခြင်းဖြစ်သည်။ အောက်ခြေလိုင်းမှာ Go language ၏ ဒီဇိုင်းသည် စမတ်ကျသော ပရိုဂရမ်မာများအတွက် မကောင်းကြောင်း ရိုးရိုးသားသား ထင်ပါတယ်။

အားနည်းသော ပရိုဂရမ်မာများအတွက် ဒီဇိုင်းထုတ်ထားပါသလား။

Go သည် သင်ယူရန် အလွန်လွယ်ကူသည်၊ ထို့ကြောင့် နိဒါန်းတွင် ကျွန်ုပ်အား တစ်ညနေတွင် ခေါ်ဆောင်သွားပြီးနောက် ကျွန်ုပ်သည် ကုဒ်ကို ကောင်းစွာ တတ်နိုင်သည် ။ ကျွန်တော်လေ့လာဖူးတဲ့စာအုပ်ကို Go လို့ခေါ်ပါတယ်။ Go in Programming အကြောင်း နိဒါန်း (ဘာသာပြန်ချက်) ၎င်းကိုအွန်လိုင်းတွင်ရရှိနိုင်သည်။ Go အရင်းအမြစ်ကုဒ်ကိုယ်တိုင်ကဲ့သို့ပင်၊ စာအုပ်သည် ဖတ်ရလွယ်ကူသည်၊ ကောင်းသောကုဒ်နမူနာများပါရှိပြီး စာမျက်နှာ ၁၅၀ ခန့်ကို တစ်ကြိမ်တည်းဖတ်နိုင်သည်။ အထူးသဖြင့် ရှုပ်ထွေးလွန်းသော နည်းပညာများဖြင့် ပြည့်နှက်နေသော ပရိုဂရမ်လောကတွင် ဤရိုးရှင်းမှုသည် အစပိုင်းတွင် လန်းဆန်းနေပါသည်။ သို့သော် နောက်ဆုံးတွင်၊ မကြာမီ သို့မဟုတ် နောက်ပိုင်းတွင် အတွေးပေါ်လာသည်– “ဒါက တကယ်ဟုတ်လား”

Google က Go ၏ရိုးရှင်းမှုသည် ၎င်း၏ရောင်းအားအချက်ဖြစ်ပြီး ဘာသာစကားသည် အသင်းကြီးများတွင် အများဆုံးထုတ်လုပ်နိုင်စွမ်းရှိစေရန် ဒီဇိုင်းထုတ်ထားသော်လည်း ၎င်းကို သံသယဖြစ်မိသည်။ ပျောက်ဆုံးနေသည် သို့မဟုတ် အသေးစိတ်လွန်းသော အင်္ဂါရပ်များ ရှိပါသည်။ ၎င်းတို့သည် မှန်ကန်သောဘာမှ မလုပ်နိုင်ဟု ယူဆချက်ဖြင့် developer များအပေါ် ယုံကြည်မှုမရှိခြင်းကြောင့် ဖြစ်သည်။ ရိုးရှင်းမှုအတွက် ဤဆန္ဒသည် ဘာသာစကား၏ ဒီဇိုင်နာများ၏ အသိဉာဏ်ဖြင့် ဆုံးဖြတ်ခဲ့ခြင်းဖြစ်ပြီး ၎င်းကို အဘယ်ကြောင့် လိုအပ်ကြောင်း အပြည့်အဝ နားလည်နိုင်ရန်၊ ဆော့ဖ်ဝဲရေးသားသူများ၏ စေ့ဆော်မှုနှင့် Go တွင် အောင်မြင်ရန် ၎င်းတို့ကြိုးစားနေသည်ကို ကျွန်ုပ်တို့ နားလည်ရပါမည်။

ဒါဆို ဘာကြောင့် ဒီလောက်ရိုးရှင်းအောင် လုပ်ထားတာလဲ။ ဤသည်မှာ ကိုးကားချက်အချို့ဖြစ်သည်။ Rob Pike (အနီးစပ်ဆုံးGo language ကို ပူးတွဲဖန်တီးသူများထဲမှ တစ်ဦး):

ဤနေရာတွင် အဓိကအချက်မှာ ကျွန်ုပ်တို့၏ ပရိုဂရမ်မာများ (အနီးစပ်ဆုံး: Googlers များ) သုတေသီများ မဟုတ်ပါ။ စည်းကမ်းအရ၊ သူတို့ဟာ ငယ်ငယ်ကတည်းက Java ကိုလေ့လာပြီး C/C++ ဒါမှမဟုတ် Python ကိုလေ့လာတာဖြစ်နိုင်ပါတယ်။ သူတို့သည် ကောင်းမွန်သောဘာသာစကားကို နားမလည်နိုင်သော်လည်း တစ်ချိန်တည်းတွင် ၎င်းတို့အား ဆော့ဖ်ဝဲလ်ကောင်းများ ဖန်တီးပေးစေလိုပါသည်။ ဒါကြောင့် သူတို့ရဲ့ဘာသာစကားဟာ သူတို့နားလည်လွယ်အောင် သင်ယူသင့်တယ်။
 
အကြမ်းဖျင်းအားဖြင့် C နှင့် ရင်းနှီးသူဖြစ်ရမည်။ Google တွင် အလုပ်လုပ်သော ပရိုဂရမ်မာများသည် ၎င်းတို့၏ အသက်မွေးဝမ်းကြောင်းလုပ်ငန်းကို အစောပိုင်းတွင် စတင်ကြပြီး အများစုမှာ အထူးသဖြင့် C မိသားစုနှင့် လုပ်ထုံးလုပ်နည်းဘာသာစကားများနှင့် ရင်းနှီးကြသည်။ ပရိုဂရမ်းမင်းဘာသာစကားအသစ်တွင် လျင်မြန်သောကုန်ထုတ်စွမ်းအားအတွက် လိုအပ်ချက်မှာ ဘာသာစကားသည် အလွန်အစွန်းရောက်မှုမဖြစ်သင့်ဟု ဆိုလိုသည်။

ဘာလဲ? ဒါကြောင့် Rob Pike က Google မှာရှိတဲ့ developer တွေက သိပ်မကောင်းဘူးလို့ အခြေခံအားဖြင့် ပြောနေတာပါ၊ ဒါကြောင့် သူတို့က idiots အတွက် ဘာသာစကားကို ဖန်တီးခဲ့တာပါ (အနီးစပ်ဆုံး: dumbed down) ဒါမှ သူတို့ တစ်ခုခု လုပ်နိုင်မှာပါ။ မင်းရဲ့ လုပ်ဖော်ကိုင်ဖက်တွေကို ဘယ်လို မာနကြီးသလဲ ? Google ၏ developer များသည် ကမ္ဘာပေါ်တွင် အတောက်ပဆုံးနှင့် အကောင်းဆုံးများထဲမှ ရွေးချယ်ခံရသည်ဟု အမြဲယုံကြည်ခဲ့သည်။ ပိုခက်ခဲတဲ့အရာကို ကိုင်တွယ်နိုင်မှာ သေချာပါတယ်။

အလွန်အကျွံရိုးရှင်းမှု၏ရှေးဟောင်းပစ္စည်း

ရိုးရှင်းခြင်းသည် မည်သည့်ဒီဇိုင်းတွင်မဆို ထိုက်တန်သောပန်းတိုင်တစ်ခုဖြစ်ပြီး ရိုးရှင်းသောအရာတစ်ခုကို ဖန်တီးရန်ကြိုးစားခြင်းသည် ခက်ခဲသည်။ သို့သော်၊ ရှုပ်ထွေးသောပြဿနာများကိုဖြေရှင်းရန်ကြိုးစားသောအခါ၊ တစ်ခါတစ်ရံတွင်ရှုပ်ထွေးသောကိရိယာတစ်ခုလိုအပ်သည်။ ရှုပ်ထွေးမှုနှင့် ရှုပ်ထွေးမှုတို့သည် ပရိုဂရမ်းမင်းဘာသာစကား၏ အကောင်းဆုံးအင်္ဂါရပ်များမဟုတ်သော်လည်း ဘာသာစကားနားလည်ရန်နှင့် အသုံးပြုရလွယ်ကူသည့် ပြေပြစ်သော abstraction များကို ဖန်တီးနိုင်သည့် အလယ်အလတ်အချက်တစ်ခုရှိသည်။

သိပ်ပြီး ထုတ်ဖော်မပြတတ်ဘူး။

ရိုးရှင်းမှုအပေါ် ၎င်း၏ကတိကဝတ်ကြောင့် Go သည် အခြားဘာသာစကားများတွင် သဘာဝဟု ထင်မြင်သည့် တည်ဆောက်မှုများ ကင်းမဲ့နေသည်။ ၎င်းသည် အစပိုင်းတွင် ကောင်းမွန်သော အကြံတစ်ခုဟု ထင်ရသော်လည်း လက်တွေ့တွင် ၎င်းသည် verbose code ကို ဖြစ်ပေါ်စေပါသည်။ ဤအရာအတွက် အကြောင်းရင်းမှာ ထင်ရှားသင့်သည် - developer များသည် အခြားသူများ၏ကုဒ်ကို ဖတ်ရန် လွယ်ကူရန် လိုအပ်သော်လည်း အမှန်တကယ်တွင် အဆိုပါရိုးရှင်းမှုများသည် ဖတ်နိုင်မှုကိုသာ ထိခိုက်စေပါသည်။ Go တွင် အတိုကောက်များ မရှိပါ။ အများကြီး သို့မဟုတ် ဘာမှ မရှိပါ။

ဥပမာအားဖြင့်၊ stdin ကိုဖတ်သော console utility သို့မဟုတ် command line arguments မှဖိုင်တစ်ခုသည်ဤကဲ့သို့ပုံရသည်-

package main

import (
    "bufio"
    "flag"
    "fmt"
    "log"
    "os"
)

func main() {

    flag.Parse()
    flags := flag.Args()

    var text string
    var scanner *bufio.Scanner
    var err error

    if len(flags) > 0 {

        file, err := os.Open(flags[0])

        if err != nil {
            log.Fatal(err)
        }

        scanner = bufio.NewScanner(file)

    } else {
        scanner = bufio.NewScanner(os.Stdin)
    }

    for scanner.Scan() {
        text += scanner.Text()
    }

    err = scanner.Err()
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(text)
}

ဤကုဒ်သည် တတ်နိုင်သမျှ ယေဘူယျဖြစ်ရန် ကြိုးပမ်းသော်လည်း Go ၏ အတင်းအကျပ် စကားကြမ်းသည် လမ်းကြောင်းပေါ် ရောက်သွားပြီး ရလဒ်အနေဖြင့် ရိုးရှင်းသော ပြဿနာကို ဖြေရှင်းခြင်းဖြင့် ကုဒ်အများအပြားကို ဖြစ်ပေါ်စေပါသည်။

ဤတွင် ဥပမာအားဖြင့် တူညီသောပြဿနာအတွက် အဖြေတစ်ခုဖြစ်သည်။ D:

import std.stdio, std.array, std.conv;

void main(string[] args)
{
    try
    {
        auto source = args.length > 1 ? File(args[1], "r") : stdin;
        auto text   = source.byLine.join.to!(string);

        writeln(text);
    }
    catch (Exception ex)
    {
        writeln(ex.msg);
    }
}

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

ကူးယူခြင်းငရဲ

Go ကို တိုးတက်စေခြင်းအတွက် ရေပန်းစားသော အကြံပြုချက်မှာ ယေဘုယျသဘောဖြစ်သည်။ ၎င်းသည် ဒေတာအမျိုးအစားအားလုံးကို ပံ့ပိုးရန်အတွက် မလိုအပ်ဘဲ ကုဒ်ကူးယူခြင်းကို ရှောင်ရှားရန် အနည်းဆုံး ကူညီပေးပါမည်။ ဥပမာအားဖြင့်၊ ကိန်းပြည့်များစာရင်းကို ပေါင်းချုပ်ရန်အတွက် လုပ်ဆောင်ချက်တစ်ခုကို ကိန်းပြည့်အမျိုးအစားတစ်ခုစီအတွက် ၎င်း၏အခြေခံလုပ်ဆောင်ချက်ကို ကူးယူပြီး ကူးထည့်ခြင်းမှလွဲ၍ အခြားနည်းလမ်းဖြင့် အကောင်အထည်မဖော်နိုင်ပါ။ အခြားနည်းလမ်းမရှိပါ။

package main

import "fmt"

func int64Sum(list []int64) (uint64) {
    var result int64 = 0
    for x := 0; x < len(list); x++ {
        result += list[x]
    }
    return uint64(result)
}

func int32Sum(list []int32) (uint64) {
    var result int32 = 0
    for x := 0; x < len(list); x++ {
        result += list[x]
    }
    return uint64(result)
}

func int16Sum(list []int16) (uint64) {
    var result int16 = 0
    for x := 0; x < len(list); x++ {
        result += list[x]
    }
    return uint64(result)
}

func int8Sum(list []int8) (uint64) {
    var result int8 = 0
    for x := 0; x < len(list); x++ {
        result += list[x]
    }
    return uint64(result)
}

func main() {

    list8  := []int8 {1, 2, 3, 4, 5}
    list16 := []int16{1, 2, 3, 4, 5}
    list32 := []int32{1, 2, 3, 4, 5}
    list64 := []int64{1, 2, 3, 4, 5}

    fmt.Println(int8Sum(list8))
    fmt.Println(int16Sum(list16))
    fmt.Println(int32Sum(list32))
    fmt.Println(int64Sum(list64))
}

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

D တွင် အလားတူ ဥပမာ

import std.stdio;
import std.algorithm;

void main(string[] args)
{
    [1, 2, 3, 4, 5].reduce!((a, b) => a + b).writeln;
}

ရိုးရိုးရှင်းရှင်း၊ အံဝင်ခွင်ကျနဲ့ ဖြောင့်ဖြောင့်ကြီးပါပဲ။ ဒီမှာသုံးတဲ့ function က reduce template အမျိုးအစားနှင့် predicate အတွက်။ ဟုတ်တယ်၊ ဒါက Go ဗားရှင်းထက် ပိုရှုပ်ထွေးပါတယ်၊ ဒါပေမယ့် smart programmer တွေအတွက်တော့ နားလည်ဖို့ သိပ်မခက်ပါဘူး။ ဘယ်ဥပမာက ထိန်းသိမ်းရ ပိုလွယ်ပြီး ဖတ်ရ ပိုလွယ်လဲ။

ရိုးရှင်းသောအမျိုးအစားစနစ်ရှောင်ကွင်း

Go ပရိုဂရမ်မာများသည် ဤစာကိုဖတ်နေသည့်အတွက် ပါးစပ်မှာ ပွက်ပွက်ဆူနေပြီး "မင်းလုပ်တာမှားနေပြီ!" ကောင်းပြီ၊ ယေဘုယျလုပ်ဆောင်ချက်နှင့် အမျိုးအစားများပြုလုပ်ရန် အခြားနည်းလမ်းတစ်ခုရှိပါသည်၊ သို့သော် ၎င်းသည် အမျိုးအစားစနစ်အား လုံးလုံးလျားလျား ချိုးဖျက်သွားပါသည်။

ပြဿနာကိုဖြေရှင်းရန် မိုက်မဲသောဘာသာစကားပြင်ဆင်မှု၏ ဤဥပမာကိုကြည့်ပါ-

package main

import "fmt"
import "reflect"

func Reduce(in interface{}, memo interface{}, fn func(interface{}, interface{}) interface{}) interface{} {
    val := reflect.ValueOf(in)

    for i := 0; i < val.Len(); i++ {
        memo = fn(val.Index(i).Interface(), memo)
    }

    return memo
}

func main() {

    list := []int{1, 2, 3, 4, 5}

    result := Reduce(list, 0, func(val interface{}, memo interface{}) interface{} {
        return memo.(int) + val.(int)
    })

    fmt.Println(result)
}

ဒါကို အကောင်အထည်ဖော်တယ်။ Reduce ဆောင်းပါးမှ ချေးယူခဲ့သည်။ Go တွင် Idiomatic generics (အနီးစပ်ဆုံးဘာသာပြန်တာကို ရှာမတွေ့လို့ ကူညီပေးရင် ဝမ်းသာပါတယ်)။ အင်း၊ အဲဒါက idiomatic ဆိုရင်၊ idiomatic မဟုတ်တဲ့ ဥပမာကို ကြည့်ရတာ မုန်းတယ်။ အသုံးပြုမှု interface{} - စာရိုက်ခြင်းကို ရှောင်ကွင်းရန်သာ လိုအပ်ပြီး၊ ၎င်းသည် အချည်းနှီးသော အင်တာဖေ့စ်တစ်ခုဖြစ်ပြီး အမျိုးအစားအားလုံးသည် ၎င်းကို အကောင်အထည်ဖော်ကာ လူတိုင်းအတွက် ပြီးပြည့်စုံသော လွတ်လပ်မှုကို ခွင့်ပြုသည်။ ဤအစီအစဉ်၏ပုံစံသည် အလွန်ရုပ်ဆိုးသည်၊ ဒါအားလုံးမဟုတ်ပေ။ ဤကဲ့သို့သော Acrobatic စွမ်းဆောင်မှုများသည် runtime ရောင်ပြန်ဟပ်မှုကိုအသုံးပြုရန်လိုအပ်သည်။ Rob Pike သည် ၎င်း၏ အစီရင်ခံစာတစ်ခုတွင် ဖော်ပြထားသည့်အတိုင်း ယင်းကို အလွဲသုံးစားလုပ်သူများကိုပင် မကြိုက်ပေ။

၎င်းသည် အစွမ်းထက်သောကိရိယာဖြစ်ပြီး သတိဖြင့်အသုံးပြုသင့်သည်။ မလိုအပ်ဘဲ ရှောင်ကြဉ်သင့်ပါတယ်။

ဒီလို အဓိပ္ပါယ်မဲ့မယ့်အစား D template တွေကို ယူချင်ပါတယ်။ ဒါကို ဘယ်သူက ဘယ်လိုပြောမလဲ။ interface{} ပိုဖတ်လို့ရတယ် ဒါမှမဟုတ် လုံခြုံအောင် ရိုက်ထည့်မလား။

မှီခိုမှုစီမံခန့်ခွဲမှု၏ဒုက္ခများ

Go တွင် လူကြိုက်များသော hosting ဝန်ဆောင်မှုပေးသူများ၏ထိပ်တွင် တည်ဆောက်ထားသည့် built-in မှီခိုမှုစနစ်တစ်ခုရှိသည်။ အတည်ပြုပြီးသောအခါကျေးရွာကော်မတီများ. Go ပါရှိသည့် ကိရိယာများသည် ဤဝန်ဆောင်မှုများအကြောင်း သိကြပြီး ၎င်းတို့ထံမှ ကုဒ်ကို ဒေါင်းလုဒ်လုပ်ခြင်း၊ တည်ဆောက်ခြင်းနှင့် တပ်ဆင်ခြင်းများ ပြုလုပ်နိုင်သည်။ ၎င်းသည် ကောင်းမွန်သော်လည်း၊ ဗားရှင်းပြုလုပ်ခြင်းတွင် အဓိက ချို့ယွင်းချက်တစ်ခု ရှိနေပါသည်။ ဟုတ်ပါတယ်၊ Go tools ကိုသုံးပြီး github သို့မဟုတ် bitbucket ကဲ့သို့သော ဝန်ဆောင်မှုများမှ အရင်းအမြစ်ကုဒ်ကို သင်ရနိုင်သည်မှာ မှန်သော်လည်း ဗားရှင်းကို သင်သတ်မှတ်၍မရပါ။ အသုံးဝင်မှုဖြင့် ရိုးရိုးရှင်းရှင်းနေတတ်ပါသည်။ ထိုသို့သော ဆုံးဖြတ်ချက်၏ ယုတ္တိကို ကျွန်ုပ် နားမလည်နိုင်ပါ။

ဤပြဿနာအတွက် အဖြေတစ်ခုအကြောင်း မေးခွန်းများမေးပြီးနောက် Go ဖွံ့ဖြိုးတိုးတက်ရေးအဖွဲ့က ဖန်တီးခဲ့သည်။ ဖိုရမ်ချည်ဒီပြဿနာကို ဘယ်လိုဖြေရှင်းကြမလဲဆိုတာကို အကြမ်းဖျင်းပြောပြထားပါတယ်။ ၎င်းတို့၏ အကြံပြုချက်မှာ သိုလှောင်မှုတစ်ခုလုံးကို သင်၏ပရောဂျက်တွင် တစ်ရက်တည်း ကူးယူကာ ၎င်းကို “ပုံစံအတိုင်း” ထားရန်ဖြစ်သည်။ သူတို့ဘာတွေတွေးနေတာလဲ။ Go ဖန်တီးသူများသည် လျစ်လျူရှုပြီး ရင်းမြစ်ကုဒ်ကို ကူးယူရုံဖြင့် ကြီးမားသော တဂ်နှင့် ဗားရှင်းပံ့ပိုးမှုဖြင့် အံ့သြဖွယ်ကောင်းသော ဗားရှင်းထိန်းချုပ်မှုစနစ်များရှိသည်။

ရှီမှ ယဉ်ကျေးမှုအိတ်

ကျွန်တော့်အမြင်အရတော့ Go ကို တစ်သက်လုံး C သုံးဖူးသူတွေနဲ့ အသစ်အဆန်းတွေကို မစမ်းချင်တဲ့သူတွေက ဖန်တီးခဲ့တာပါ။ ဘာသာစကားကို အပိုဘီးများဖြင့် C အဖြစ်ဖော်ပြနိုင်သည်(orig: လေ့ကျင့်ရေးဘီးများ) မျဉ်းပြိုင်ဝါဒကို ပံ့ပိုးပေးရုံမှတပါး (စကားအားဖြင့် အံ့သြဖွယ်ကောင်းသည်) မှလွဲ၍ ၎င်းတွင် စိတ်ကူးအသစ်များ မရှိပါ။ သင့်တွင် အသုံးမဝင်သလောက်၊ ခြေဆွံ့သောဘာသာစကားဖြင့် ပြိုင်တူလွန်ကဲမှုရှိသည်။

နောက်ထပ် ထိတ်လန့်စရာပြဿနာမှာ Go သည် လုပ်ထုံးလုပ်နည်းဘာသာစကား (C ၏ အသံတိတ်ထိတ်လန့်စရာကဲ့သို့) ဖြစ်သည်။ ရှေးရိုးဆန်ပြီး ခေတ်မမီသလိုခံစားရသော လုပ်ထုံးလုပ်နည်းပုံစံဖြင့် ကုဒ်ရေးခြင်းကို အဆုံးသတ်ပါသည်။ Object Oriented Programming သည် ငွေရောင်ကျည်ဆန်မဟုတ်ကြောင်း သိပါသည်၊ သို့သော် အသေးစိတ်အချက်အလက်များကို အမျိုးအစားများအဖြစ် abstract လုပ်ပြီး encapsulation ပေးစွမ်းနိုင်ခြင်းသည် ကောင်းပါတယ်။

ကိုယ့်အကျိုးအတွက် ရိုးရှင်းတယ်။

Go ကို ရိုးရှင်းစေရန် ဒီဇိုင်းထုတ်ထားပြီး ထိုပန်းတိုင်တွင် အောင်မြင်သည်။ အားနည်းသော ပရိုဂရမ်မာများအတွက် တမ်းပလိတ်အဖြစ် ဘာသာစကားဟောင်းကို အသုံးပြု၍ ရေးသားထားသည်။ ၎င်းသည် ရိုးရှင်းသောအရာများကို လုပ်ဆောင်ရန် ရိုးရှင်းသောကိရိယာများဖြင့် အပြည့်အစုံပါရှိသည်။ ၎င်းသည်ဖတ်ရန်လွယ်ကူပြီးအသုံးပြုရလွယ်ကူသည်။

၎င်းသည် စမတ်ကျသော ပရိုဂရမ်မာများအတွက် အလွန်အမိုက်စား၊ အထင်ကြီးလောက်စရာနှင့် မကောင်းပါ။

Спасибо mersinvald တည်းဖြတ်မှုများအတွက်

source: www.habr.com