ហេតុអ្វីបានជា Go Design មិនល្អសម្រាប់អ្នកសរសេរកម្មវិធីឆ្លាតវៃ

ក្នុងរយៈពេលប៉ុន្មានខែកន្លងមកនេះ ខ្ញុំបានប្រើប្រាស់ Go សម្រាប់ការអនុវត្ត។ ភស្តុតាងនៃគំនិត។ (ប្រហែល: កូដដើម្បីសាកល្បងមុខងារនៃគំនិតមួយ) ពេលទំនេររបស់គាត់ មួយផ្នែកដើម្បីសិក្សាភាសាសរសេរកម្មវិធីខ្លួនឯង។ កម្មវិធីខ្លួនឯងគឺសាមញ្ញណាស់ ហើយមិនមែនជាគោលបំណងនៃអត្ថបទនេះទេ ប៉ុន្តែបទពិសោធន៍នៃការប្រើប្រាស់ Go ខ្លួនវាសមនឹងទទួលបានពាក្យពីរបីអំពីវា។ ទៅសន្យានឹង (ប្រហែល៖ អត្ថបទសរសេរក្នុងឆ្នាំ 2015) ជាភាសាពេញនិយមសម្រាប់កូដដែលអាចធ្វើមាត្រដ្ឋានបាន។ ភាសានេះត្រូវបានបង្កើតឡើងដោយ Google ដែលវាត្រូវបានប្រើប្រាស់យ៉ាងសកម្ម។ ចំណុចខាងក្រោម ខ្ញុំគិតដោយស្មោះត្រង់ថាការរចនានៃភាសា Go គឺមិនល្អសម្រាប់អ្នកសរសេរកម្មវិធីឆ្លាតវៃ។

រចនាសម្រាប់អ្នកសរសេរកម្មវិធីខ្សោយ?

Go គឺងាយស្រួលរៀនណាស់ ងាយស្រួលណាស់ដែលការណែនាំបាននាំខ្ញុំនៅល្ងាចមួយ បន្ទាប់មកខ្ញុំអាចសរសេរកូដបានយ៉ាងមានប្រសិទ្ធភាព។ សៀវភៅដែលខ្ញុំធ្លាប់រៀន Go ត្រូវបានគេហៅថា ការណែនាំអំពីការសរសេរកម្មវិធីនៅក្នុង Go (ការបកប្រែ), វាមាននៅលើអ៊ីនធឺណិត។ សៀវភៅនេះ ដូចជាកូដប្រភព Go ផ្ទាល់ ងាយស្រួលអាន មានឧទាហរណ៍កូដល្អ និងមានប្រហែល 150 ទំព័រដែលអាចអានបានក្នុងមួយលើក។ ភាពសាមញ្ញនេះមានភាពស្រស់ស្រាយនៅពេលដំបូង ជាពិសេសនៅក្នុងពិភពសរសេរកម្មវិធីដែលពោរពេញទៅដោយបច្ចេកវិទ្យាស្មុគស្មាញ។ ប៉ុន្តែ​នៅ​ទី​បំផុត មិន​យូរ​មិន​ឆាប់​គំនិត​មួយ​កើត​ឡើង​ថា “តើ​នេះ​ពិត​ជា​ដូច្នេះ​មែន​ទេ?”

Google អះអាងថាភាពសាមញ្ញរបស់ Go គឺជាចំណុចលក់របស់វា ហើយភាសានេះត្រូវបានរចនាឡើងសម្រាប់ផលិតភាពអតិបរមានៅក្នុងក្រុមធំ ប៉ុន្តែខ្ញុំសង្ស័យវា។ មានលក្ខណៈពិសេសដែលបាត់ ឬលម្អិតហួសហេតុ។ ហើយទាំងអស់ដោយសារតែខ្វះការជឿទុកចិត្តលើអ្នកអភិវឌ្ឍន៍ ជាមួយនឹងការសន្មត់ថាពួកគេមិនអាចធ្វើអ្វីបានត្រឹមត្រូវ។ បំណងប្រាថ្នាសម្រាប់ភាពសាមញ្ញនេះគឺជាការសម្រេចចិត្តដោយមនសិការរបស់អ្នករចនាភាសា ហើយដើម្បីយល់ច្បាស់ពីមូលហេតុដែលវាត្រូវការ យើងត្រូវយល់ពីការលើកទឹកចិត្តរបស់អ្នកអភិវឌ្ឍន៍ និងអ្វីដែលពួកគេកំពុងព្យាយាមសម្រេចបាននៅក្នុង Go ។

ដូច្នេះហេតុអ្វីបានជាវាត្រូវបានធ្វើឱ្យសាមញ្ញដូច្នេះ? នេះគឺជាសម្រង់ពីរបី លោក Rob Pike (ប្រហែល៖ ម្នាក់ក្នុងចំណោមអ្នកបង្កើតភាសា Go)៖

ចំណុចសំខាន់នៅទីនេះគឺថាអ្នកសរសេរកម្មវិធីរបស់យើង (ប្រហែល: Googlers) មិនមែនជាអ្នកស្រាវជ្រាវទេ។ តាមក្បួនមួយ ពួកគេនៅក្មេងណាស់ មករកយើងបន្ទាប់ពីសិក្សា ប្រហែលជាពួកគេបានសិក្សា Java ឬ C/C++ ឬ Python ។ ពួកគេ​មិន​អាច​យល់​ភាសា​ដ៏​អស្ចារ្យ​មួយ​នោះ​ទេ ប៉ុន្តែ​ក្នុង​ពេល​ជាមួយ​គ្នា​នោះ យើង​ចង់​ឱ្យ​ពួកគេ​បង្កើត​កម្មវិធី​ល្អ​។ នោះហើយជាមូលហេតុដែលភាសារបស់ពួកគេគួរតែងាយស្រួលសម្រាប់ពួកគេក្នុងការយល់ និងរៀន។
 
គាត់​គួរ​តែ​ស្គាល់​ប្រហែល​និយាយ​ស្រដៀង​នឹង C. អ្នកសរសេរកម្មវិធីដែលធ្វើការនៅ Google ចាប់ផ្តើមអាជីពដំបូងរបស់ពួកគេ ហើយភាគច្រើនស្គាល់ភាសានីតិវិធី ជាពិសេសគ្រួសារ C ។ តម្រូវការសម្រាប់ផលិតភាពរហ័សក្នុងភាសាសរសេរកម្មវិធីថ្មីមានន័យថា ភាសាមិនគួរមានលក្ខណៈរ៉ាឌីកាល់ពេកទេ។

អ្វី? ដូច្នេះ Rob Pike និយាយជាមូលដ្ឋានថាអ្នកអភិវឌ្ឍន៍នៅ Google មិនល្អទេ នោះហើយជាមូលហេតុដែលពួកគេបង្កើតភាសាសម្រាប់មនុស្សល្ងង់ (ប្រហែល: dumbed down) ដើម្បីឱ្យពួកគេអាចធ្វើអ្វីមួយបាន។ មើល​មិត្ត​រួម​ការងារ​ខ្លួន​ឯង​ក្រអឺតក្រទម​បែប​ណា? ខ្ញុំតែងតែជឿថាអ្នកអភិវឌ្ឍន៍របស់ Google ត្រូវបានជ្រើសរើសដោយអ្នកភ្លឺបំផុត និងល្អបំផុតនៅលើផែនដី។ តើ​ពួក​គេ​ប្រាកដ​ជា​អាច​ដោះស្រាយ​អ្វី​ដែល​ពិបាក​ជាង​នេះ​ទេ?

វត្ថុបុរាណនៃភាពសាមញ្ញហួសហេតុ

ភាពសាមញ្ញគឺជាគោលដៅដ៏សក្តិសមក្នុងការរចនាណាមួយ ហើយការព្យាយាមធ្វើឱ្យអ្វីដែលសាមញ្ញគឺពិបាកណាស់។ ទោះយ៉ាងណាក៏ដោយនៅពេលព្យាយាមដោះស្រាយបញ្ហាស្មុគស្មាញ (ឬសូម្បីតែបង្ហាញ) ជួនកាលឧបករណ៍ស្មុគស្មាញគឺចាំបាច់។ ភាពស្មុគ្រស្មាញ និងភាពស្មុគ្រស្មាញមិនមែនជាលក្ខណៈល្អបំផុតនៃភាសាសរសេរកម្មវិធីនោះទេ ប៉ុន្តែវាមានមូលដ្ឋានកណ្តាលដែលភាសាអាចបង្កើតអរូបីដ៏ឆើតឆាយ ដែលងាយស្រួលយល់ និងប្រើប្រាស់។

មិនបញ្ចេញមតិខ្លាំង

ដោយសារតែការប្តេជ្ញាចិត្តរបស់ខ្លួនចំពោះភាពសាមញ្ញ Go ខ្វះការស្ថាបនាដែលត្រូវបានគេយល់ថាជាធម្មជាតិនៅក្នុងភាសាផ្សេងទៀត។ នេះ​ប្រហែល​ជា​ជា​គំនិត​ល្អ​ដំបូង​ឡើយ ប៉ុន្តែ​ក្នុង​ការ​អនុវត្ត​វា​ជា​លទ្ធផល​នៃ​ការ​សរសេរ​កូដ។ ហេតុផលសម្រាប់រឿងនេះគួរតែច្បាស់ - វាត្រូវការភាពងាយស្រួលសម្រាប់អ្នកអភិវឌ្ឍន៍ក្នុងការអានកូដរបស់អ្នកដទៃ ប៉ុន្តែតាមពិត ភាពសាមញ្ញទាំងនេះប៉ះពាល់តែការអានប៉ុណ្ណោះ។ មិនមានអក្សរកាត់នៅក្នុង Go: ច្រើន ឬគ្មានអ្វីសោះ។

ឧទាហរណ៍ ឧបករណ៍ប្រើប្រាស់កុងសូលដែលអាន stdin ឬឯកសារពីអាគុយម៉ង់បន្ទាត់ពាក្យបញ្ជានឹងមើលទៅដូចនេះ៖

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. កូដ​របស់​គាត់​គឺ​អាច​អាន​បាន​ច្រើន​ជាង ព្រោះ​គាត់​ពណ៌នា​សកម្មភាព​កាន់​តែ​ច្បាស់។ ឃ ប្រើគំនិតស្មុគ្រស្មាញច្រើន (ប្រហែល: ការហៅមុខងារជំនួស и គំរូ) ជាងនៅក្នុងឧទាហរណ៍ 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))
}

ហើយឧទាហរណ៍នេះមិនដំណើរការសម្រាប់ប្រភេទដែលបានចុះហត្ថលេខាទេ។ វិធីសាស្រ្តនេះបំពានទាំងស្រុងលើគោលការណ៍នៃការមិនធ្វើម្តងទៀតដោយខ្លួនឯង (ស្ងួត) គោលការណ៍ដ៏ល្បីល្បាញ និងជាក់ស្តែងបំផុតមួយ ការមិនអើពើ ដែលជាប្រភពនៃកំហុសជាច្រើន។ ហេតុអ្វី Go ធ្វើបែបនេះ? នេះគឺជាទិដ្ឋភាពដ៏គួរឱ្យភ័យខ្លាចនៃភាសា។

ឧទាហរណ៍ដូចគ្នានៅលើ D:

import std.stdio;
import std.algorithm;

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

សាមញ្ញ ឆើតឆាយ និងត្រង់ទៅចំណុច។ មុខងារដែលប្រើនៅទីនេះគឺ reduce សម្រាប់ប្រភេទគំរូ និងព្យាករណ៍។ បាទ នេះ​គឺ​ជា​ការ​ស្មុគស្មាញ​ម្ដង​ទៀត​ជាង​កំណែ Go ប៉ុន្តែ​មិន​ពិបាក​សម្រាប់​អ្នក​សរសេរ​កម្មវិធី​ឆ្លាតវៃ​ក្នុង​ការ​យល់​នោះ​ទេ។ តើ​ឧទាហរណ៍​មួយ​ណា​ដែល​ងាយ​ស្រួល​ក្នុង​ការ​រក្សា និង​ងាយ​អាន?

ប្រព័ន្ធផ្លូវវាងប្រភេទសាមញ្ញ

ខ្ញុំស្រមៃថាអ្នកសរសេរកម្មវិធី 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, ខ្ញុំចង់ឃើញឧទាហរណ៍ដែលមិនមែនជា idiomatic ។ ការប្រើប្រាស់ interface{} - farce ហើយនៅក្នុងភាសាវាត្រូវការតែដើម្បីរំលងការវាយ។ នេះគឺជាចំណុចប្រទាក់ទទេ ហើយគ្រប់ប្រភេទអនុវត្តវា ដែលអនុញ្ញាតឱ្យមានសេរីភាពពេញលេញសម្រាប់មនុស្សគ្រប់គ្នា។ រចនាប័ទ្មនៃកម្មវិធីនេះគឺអាក្រក់ណាស់ ហើយនោះមិនមែនទាំងអស់នោះទេ។ សកម្មភាពកាយសម្ព័ន្ធបែបនេះតម្រូវឱ្យប្រើការឆ្លុះបញ្ចាំងពេលរត់។ សូម្បីតែ Rob Pike មិនចូលចិត្តបុគ្គលដែលបំពានលើរឿងនេះ ដូចដែលគាត់បានលើកឡើងនៅក្នុងរបាយការណ៍មួយរបស់គាត់។

នេះគឺជាឧបករណ៍ដ៏មានឥទ្ធិពលដែលគួរប្រើដោយប្រុងប្រយ័ត្ន។ វាគួរតែត្រូវបានជៀសវាងលុះត្រាតែចាំបាច់។

ខ្ញុំនឹងយកគំរូ D ជំនួសឱ្យការសមហេតុសមផលនេះ។ តើ​អ្នក​ណា​អាច​និយាយ​បែប​នេះ​ដោយ​របៀប​ណា interface{} អាច​អាន​បាន​ច្រើន​ជាង ឬ​សូម្បី​តែ​វាយ​ដោយ​សុវត្ថិភាព?

វិបត្តិនៃការគ្រប់គ្រងភាពអាស្រ័យ

Go មានប្រព័ន្ធពឹងផ្អែកដែលភ្ជាប់មកជាមួយដែលត្រូវបានបង្កើតឡើងនៅលើកំពូលនៃអ្នកផ្តល់សេវាបង្ហោះពេញនិយម VCS ។. ឧបករណ៍ដែលភ្ជាប់មកជាមួយ Go ដឹងពីសេវាកម្មទាំងនេះ ហើយអាចទាញយក បង្កើត និងដំឡើងកូដពីពួកវាបានភ្លាមៗ។ ខណៈ​នេះ​គឺ​ជា​ការ​អស្ចារ្យ, មាន​កំហុស​ចម្បង​ជាមួយ​នឹង​កំណែ​! បាទ/ចាស វាជាការពិតដែលអ្នកអាចទទួលបានកូដប្រភពពីសេវាកម្មដូចជា github ឬ bitbucket ដោយប្រើឧបករណ៍ Go ប៉ុន្តែអ្នកមិនអាចបញ្ជាក់កំណែបានទេ។ ហើយម្តងទៀតភាពសាមញ្ញដោយចំណាយនៃប្រយោជន៍។ ខ្ញុំមិនអាចយល់ពីតក្កវិជ្ជានៃការសម្រេចចិត្តបែបនេះទេ។

បន្ទាប់ពីសួរសំណួរអំពីដំណោះស្រាយចំពោះបញ្ហានេះ ក្រុមអភិវឌ្ឍន៍ Go បានបង្កើត វេទិកាដែលរៀបរាប់ពីរបៀបដែលពួកគេនឹងទាក់ទងបញ្ហានេះ។ ការណែនាំរបស់ពួកគេគឺគ្រាន់តែចម្លងឃ្លាំងទាំងមូលទៅក្នុងគម្រោងរបស់អ្នកមួយថ្ងៃ ហើយទុកវាឱ្យ "ដូចដែលនៅ"។ តើពួកគេកំពុងគិតអ្វី? យើងមានប្រព័ន្ធគ្រប់គ្រងកំណែដ៏អស្ចារ្យជាមួយនឹងការដាក់ស្លាក និងការគាំទ្រកំណែដ៏អស្ចារ្យដែលអ្នកបង្កើត Go មិនអើពើ ហើយគ្រាន់តែចម្លងកូដប្រភពប៉ុណ្ណោះ។

ឥវ៉ាន់វប្បធម៌ពីស៊ី

តាមគំនិតរបស់ខ្ញុំ Go ត្រូវបានបង្កើតឡើងដោយអ្នកដែលបានប្រើ C ពេញមួយជីវិតរបស់ពួកគេ និងដោយអ្នកដែលមិនចង់សាកល្បងអ្វីដែលថ្មី។ ភាសាអាចត្រូវបានពិពណ៌នាថាជា C ជាមួយនឹងកង់បន្ថែម (ដើម។: កង់ហ្វឹកហាត់) មិនមានគំនិតថ្មីនៅក្នុងវាទេលើកលែងតែការគាំទ្រសម្រាប់ភាពស្របគ្នា (ដែលតាមវិធីនេះគឺអស្ចារ្យណាស់) ហើយនេះគឺជាការអាម៉ាស់មួយ។ អ្នកមានភាពស្របគ្នាដ៏ល្អឥតខ្ចោះនៅក្នុងភាសាដែលស្ទើរតែមិនអាចប្រើប្រាស់បាន។

បញ្ហាដ៏គួរឱ្យភ្ញាក់ផ្អើលមួយទៀតគឺថា Go គឺជាភាសានីតិវិធី (ដូចជាភាពភ័យរន្ធត់ស្ងាត់របស់ C) ។ អ្នកបញ្ចប់ការសរសេរកូដក្នុងរចនាប័ទ្មនីតិវិធីដែលមានអារម្មណ៍ថាចាស់ និងហួសសម័យ។ ខ្ញុំដឹងថាកម្មវិធីតម្រង់ទិសវត្ថុមិនមែនជាគ្រាប់កាំភ្លើងទេ ប៉ុន្តែវាជាការប្រសើរណាស់ក្នុងការអាចសង្ខេបព័ត៌មានលម្អិតទៅជាប្រភេទ និងផ្តល់នូវការវេចខ្ចប់។

ភាពសាមញ្ញសម្រាប់ផលប្រយោជន៍ផ្ទាល់ខ្លួនរបស់អ្នក។

Go ត្រូវ​បាន​រចនា​ឡើង​ឱ្យ​សាមញ្ញ ហើយ​វា​ទទួល​បាន​ជោគជ័យ​តាម​គោលដៅ​នោះ។ វាត្រូវបានសរសេរសម្រាប់អ្នកសរសេរកម្មវិធីខ្សោយ ដោយប្រើភាសាចាស់ជាគំរូ។ វាភ្ជាប់មកជាមួយនូវឧបករណ៍សាមញ្ញៗដើម្បីធ្វើរឿងសាមញ្ញៗ។ វាងាយស្រួលអាន និងងាយស្រួលប្រើ។

វា​ជា​ពាក្យ​សំដី​មិន​គួរឱ្យ​ចាប់អារម្មណ៍ និង​អាក្រក់​បំផុត​សម្រាប់​អ្នកសរសេរ​កម្មវិធី​ឆ្លាតវៃ។

ស្ទ្រីម Mersinvald សម្រាប់ការកែសម្រួល

ប្រភព: www.habr.com