ඇයි Go Design Smart Programmers සඳහා නරක වන්නේ

පසුගිය මාස කිහිපය තුළ මම ක්‍රියාත්මක කිරීම් සඳහා Go භාවිත කළා. සංකල්පයේ සාධනය (ආසන්න වශයෙන්: අදහසක ක්‍රියාකාරීත්වය පරීක්ෂා කිරීම සඳහා කේතය) ඔහුගේ නිදහස් කාලය තුළ, අර්ධ වශයෙන් ක්‍රමලේඛන භාෂාව අධ්‍යයනය කිරීම. වැඩසටහන් ඉතා සරල වන අතර මෙම ලිපියේ අරමුණ නොවේ, නමුත් Go භාවිතා කිරීමේ අත්දැකීම ඒ ගැන වචන කිහිපයක් වටී. යන්න පොරොන්දු වෙනවා (ආසන්න වශයෙන්: 2015 දී ලියන ලද ලිපිය) බරපතල පරිමාණය කළ හැකි කේතය සඳහා ජනප්‍රිය භාෂාවකි. භාෂාව Google විසින් නිර්මාණය කරන ලද අතර එය සක්‍රියව භාවිතා වේ. පහළම රේඛාව, මම අවංකවම සිතන්නේ Go භාෂාවේ සැලසුම ස්මාර්ට් ක්‍රමලේඛකයින්ට නරක බවයි.

දුර්වල ක්‍රමලේඛකයින් සඳහා නිර්මාණය කර තිබේද?

යන්න ඉගෙන ගැනීම ඉතා පහසුයි, කෙතරම් පහසුද යත්, හැඳින්වීම මට එක් සැන්දෑවක් ගෙන ගියේය, ඉන් පසුව මට දැනටමත් ඵලදායි ලෙස කේත කිරීමට හැකි විය. මම ඉස්සර Go ඉගෙන ගත්ත පොත තමයි කියන්නේ Go හි වැඩසටහන්කරණය පිළිබඳ හැඳින්වීමක් (පරිවර්තනයයි), එය මාර්ගගතව ඇත. මෙම පොත, Go මූලාශ්‍ර කේතය මෙන්, කියවීමට පහසු වන අතර, හොඳ කේත උදාහරණ ඇති අතර, එක් වරකදී කියවිය හැකි පිටු 150ක් පමණ අඩංගු වේ. මෙම සරල බව මුලදී ප්‍රබෝධමත් කරයි, විශේෂයෙන් අතිශය සංකීර්ණ තාක්‍ෂණයෙන් පිරුණු ක්‍රමලේඛන ලෝකයක. නමුත් අවසානයේදී, ඉක්මනින් හෝ පසුව සිතුවිල්ල පැන නගී: "මෙය ඇත්තෙන්ම එසේද?"

Go හි සරල බව එහි විකුණුම් ලක්ෂ්‍යය බව Google ප්‍රකාශ කරන අතර භාෂාව විශාල කණ්ඩායම්වල උපරිම ඵලදායිතාව සඳහා නිර්මාණය කර ඇත, නමුත් මට එය සැකයි. නැතිවූ හෝ ඕනෑවට වඩා විස්තර සහිත විශේෂාංග තිබේ. එමෙන්ම සංවර්ධකයින් කෙරෙහි විශ්වාසයක් නොමැතිකම නිසා, ඔවුන්ට කිසිවක් නිවැරදිව කිරීමට නොහැකි යැයි උපකල්පනය කරමින්. සරලත්වය සඳහා වූ මෙම ආශාව භාෂාවේ නිර්මාණකරුවන් විසින් දැනුවත් තීරණයක් වූ අතර, එය අවශ්‍ය වූයේ මන්දැයි සම්පූර්ණයෙන් අවබෝධ කර ගැනීම සඳහා, සංවර්ධකයින්ගේ අභිප්‍රේරණය සහ ඔවුන් Go හි සාක්ෂාත් කර ගැනීමට උත්සාහ කළ දේ අප තේරුම් ගත යුතුය.

එසේනම් එය එතරම් සරල කළේ ඇයි? මෙන්න උපුටා දැක්වීම් කිහිපයක් රොබ් පයික් (ආසන්න වශයෙන්: Go භාෂාවේ සම-නිර්මාතෘවරුන්ගෙන් කෙනෙක්):

මෙහි ප්‍රධාන කරුණ නම් අපගේ ක්‍රමලේඛකයින් (ආසන්න වශයෙන්: ගූගල් කරන්නන්) පර්යේෂකයන් නොවේ. ඔවුන්, රීතියක් ලෙස, තරමක් තරුණ, ඉගෙනීමෙන් පසු අප වෙත පැමිණ, සමහර විට ඔවුන් Java, හෝ C/C++, හෝ Python ඉගෙන ගත්තා. එයාලට ලොකු භාෂාවක් තේරෙන්නේ නෑ, ඒත් එක්කම අපිට ඕනේ එයාලට හොඳ Software හදන්න. ඒ නිසා ඔවුන්ගේ භාෂාව ඔවුන්ට තේරුම් ගැනීමට සහ ඉගෙන ගැනීමට පහසු විය යුතුය.
 
ඔහු හුරුපුරුදු විය යුතුය, දළ වශයෙන් C ට සමාන ය. Google හි වැඩ කරන ක්‍රමලේඛකයින් ඔවුන්ගේ වෘත්තීය ජීවිතය කලින් ආරම්භ කරන අතර බොහෝ දුරට පරිපාටිමය භාෂා, විශේෂයෙන්ම C පවුල ගැන හුරුපුරුදුය. නව ක්‍රමලේඛන භාෂාවක ඉක්මන් ඵලදායිතාවයක් අවශ්‍ය වන්නේ භාෂාව ඉතා රැඩිකල් නොවිය යුතු බවයි.

කුමක් ද? ඉතින් Rob Pike මූලිකවම කියන්නේ Google එකේ developers ලා එච්චර හොඳ නෑ, ඒ නිසා තමයි ඔවුන් මෝඩයන්ට භාෂාවක් හැදුවේ (ආසන්න වශයෙන්: ගොළු විය) එවිට ඔවුන්ට යමක් කිරීමට හැකි වේ. ඔබේම සගයන් දෙස බලන්නේ කුමන ආකාරයේ උඩඟු බැල්මක්ද? 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 ට දෙන්නම්. ඔහු ක්‍රියාවන් වඩාත් පැහැදිලිව විස්තර කරන බැවින් ඔහුගේ කේතය බොහෝ සෙයින් කියවිය හැකිය. 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 programmers කටින් පෙණ දමමින්, “ඔයා කරන්නේ වැරදියි!” කියා කෑගසයි. හොඳයි, සාමාන්‍ය ශ්‍රිතයක් සහ වර්ග සෑදීමට තවත් ක්‍රමයක් තිබේ, නමුත් එය ටයිප් පද්ධතිය සම්පූර්ණයෙන්ම බිඳ දමයි!

ගැටලුව විසඳා ගැනීමට මෝඩ භාෂා විසඳුමක් පිළිබඳ මෙම උදාහරණය බලන්න:

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 හි මුග්ධ ජනක (ආසන්න වශයෙන්: මට පරිවර්තනය සොයා ගැනීමට නොහැකි විය, ඔබ මේ සඳහා උදව් කරන්නේ නම් මම සතුටු වෙමි). හොඳයි, එය ව්‍යාකූල නම්, මම ව්‍යාකූල නොවන උදාහරණයක් දැකීමට අකමැතියි. භාවිතය interface{} - විහිළුවක්, සහ භාෂාවෙන් එය අවශ්‍ය වන්නේ ටයිප් කිරීම මග හැරීමට පමණි. මෙය හිස් අතුරු මුහුණතක් වන අතර සියලු වර්ගයන් එය ක්‍රියාත්මක කරයි, සෑම කෙනෙකුටම සම්පූර්ණ නිදහස ලබා දෙයි. මෙම ක්‍රමලේඛන විලාසය දරුණු ලෙස කැතයි, එපමණක් නොවේ. මෙවැනි ඇක්‍රොබැටික් ක්‍රියා සඳහා ධාවන කාල පරාවර්තනය භාවිතා කිරීම අවශ්‍ය වේ. රොබ් පයික් පවා ඔහුගේ වාර්තාවක සඳහන් කළ පරිදි මෙය අනිසි ලෙස භාවිතා කරන පුද්ගලයින්ට කැමති නැත.

මෙය ප්‍රවේශමෙන් භාවිතා කළ යුතු ප්‍රබල මෙවලමකි. දැඩි ලෙස අවශ්ය නම් මිස එය වළක්වා ගත යුතුය.

මම මේ විකාර වෙනුවට D සැකිලි ගන්නම්. කවුරුහරි එහෙම කියන්නේ කොහොමද interface{} වඩා කියවිය හැකි හෝ ආරක්ෂිත ටයිප් කරන්නද?

යැපුම් කළමනාකරණයේ දුක්ඛිත තත්වයන්

Go සතුව ජනප්‍රිය සත්කාරක සපයන්නන් මත ගොඩනගා ඇති පරායත්ත පද්ධතියක් ඇත VCS. Go සමඟ එන මෙවලම් මෙම සේවාවන් ගැන දන්නා අතර ඒවායින් එක පහරකින් කේතය බාගත කිරීමට, ගොඩනැගීමට සහ ස්ථාපනය කිරීමට හැකිය. මෙය විශිෂ්ට වුවත්, අනුවාදයේ විශාල දෝෂයක් තිබේ! ඔව්, ඇත්ත වශයෙන්ම, ඔබට Go මෙවලම් භාවිතයෙන් github හෝ bitbucket වැනි සේවාවන් වෙතින් මූලාශ්‍ර කේතය ලබා ගත හැක, නමුත් ඔබට අනුවාදය සඳහන් කළ නොහැක. නැවතත් ප්රයෝජනවත් වියදමෙන් සරල බව. එවැනි තීරණයක තර්කනය මට තේරුම් ගත නොහැක.

මෙම ගැටලුවට විසඳුමක් ගැන ප්රශ්න ඇසීමෙන් පසුව, Go සංවර්ධන කණ්ඩායම නිර්මාණය කළේය සංසදයේ නූල්, ඔවුන් මෙම ප්‍රශ්නය මග හරවා ගන්නේ කෙසේද යන්න ගෙනහැර දක්වා ඇත. ඔවුන්ගේ නිර්දේශය වූයේ එක් දිනක් ඔබේ ව්‍යාපෘතියට සම්පූර්ණ ගබඩාව පිටපත් කර "එසේම" තැබීමයි. මොන මගුලක්ද මුන් කල්පනා කරන්නේ. Go නිර්මාපකයින් නොසලකා හරින සහ ප්‍රභව කේතය පිටපත් කරන විශිෂ්ට ටැගින් සහ අනුවාද සහාය සහිත විස්මිත අනුවාද පාලන පද්ධති අප සතුව ඇත.

Xi වෙතින් සංස්කෘතික ගමන් මලු

මගේ මතය අනුව, Go වර්ධනය කර ඇත්තේ ඔවුන්ගේ ජීවිත කාලය පුරාම C භාවිතා කළ අය සහ අලුත් දෙයක් උත්සාහ කිරීමට අකමැති අය විසිනි. භාෂාව අමතර රෝද සහිත C ලෙස විස්තර කළ හැක(මුල්.: පුහුණු රෝද) සමාන්තරකරණයට සහාය වීම හැර එහි නව අදහස් නොමැත (එය, මාර්ගය වන විට, අපූරු ය) සහ මෙය ලැජ්ජාවකි. යන්තම් භාවිතා කළ හැකි, ලාමක භාෂාවකින් ඔබට විශිෂ්ට සමාන්තරකරණයක් ඇත.

තවත් ප්‍රශ්නයක් වන්නේ Go යනු ක්‍රියා පටිපාටි භාෂාවක් වීමයි (C හි නිහඬ භීෂණය වැනි). ඔබ කේත ලිවීම අවසන් කරන්නේ පෞරාණික සහ යල් පැන ගිය බවක් හැඟෙන ක්‍රියා පටිපාටි ශෛලියකින්. වස්තු නැඹුරු ක්‍රමලේඛනය රිදී උණ්ඩයක් නොවන බව මම දනිමි, නමුත් විස්තර වර්ග වලට සාරාංශ කර සංග්‍රහයක් ලබා දීමට හැකි නම් එය ඉතා හොඳ වනු ඇත.

ඔබේම ප්රයෝජනය සඳහා සරල බව

Go නිර්මාණය කර ඇත්තේ සරල ලෙස වන අතර එය එම ඉලක්කයට සාර්ථක වේ. එය ලියා ඇත්තේ දුර්වල ක්‍රමලේඛකයින් සඳහා පැරණි භාෂාවක් අච්චුවක් ලෙස භාවිතා කරමිනි. එය සරල දේවල් කිරීමට සරල මෙවලම් සමඟ සම්පුර්ණ වේ. එය කියවීමට පහසු සහ භාවිතා කිරීමට පහසුය.

එය අතිශයින්ම වාචික, සිත් ඇදගන්නාසුළු නොවන අතර දක්ෂ ක්‍රමලේඛකයින්ට නරක ය.

ස්තුතියි මර්සින්වෝල්ඩ් සංස්කරණ සඳහා

මූලාශ්රය: www.habr.com