ஸ்மார்ட் புரோகிராமர்களுக்கு கோ டிசைன் ஏன் மோசமானது

கடந்த மாதங்களில் நான் செயல்படுத்தல்களுக்கு Go ஐப் பயன்படுத்துகிறேன். கருத்து ஆதாரம் (தோராயமாக: ஒரு யோசனையின் செயல்பாட்டைச் சோதிக்க குறியீடு) தனது ஓய்வு நேரத்தில், ஓரளவு நிரலாக்க மொழியைப் படிக்க வேண்டும். நிரல்களே மிகவும் எளிமையானவை மற்றும் இந்த கட்டுரையின் நோக்கம் அல்ல, ஆனால் Go ஐப் பயன்படுத்தும் அனுபவம் அதைப் பற்றி சில வார்த்தைகளுக்குத் தகுதியானது. Go உறுதியளிக்கிறது (தோராயமாக: 2015 இல் எழுதப்பட்ட கட்டுரை) தீவிர அளவிடக்கூடிய குறியீட்டிற்கான பிரபலமான மொழி. இந்த மொழி கூகுளால் உருவாக்கப்பட்டது, அங்கு அது தீவிரமாகப் பயன்படுத்தப்படுகிறது. கீழே வரி, கோ மொழியின் வடிவமைப்பு ஸ்மார்ட் புரோகிராமர்களுக்கு மோசமானது என்று நான் நேர்மையாக நினைக்கிறேன்.

பலவீனமான புரோகிராமர்களுக்காக வடிவமைக்கப்பட்டதா?

கோ கற்றுக்கொள்வது மிகவும் எளிதானது, மிகவும் எளிதானது, அறிமுகம் ஒரு மாலை எனக்கு எடுத்துக்கொண்டது, அதன் பிறகு நான் ஏற்கனவே உற்பத்தி ரீதியாக குறியீடு செய்ய முடியும். நான் கோ கற்றுக்கொண்ட புத்தகம் என்று அழைக்கப்படுகிறது Go இல் நிரலாக்கத்திற்கான ஒரு அறிமுகம் (மொழிபெயர்ப்பு), இது ஆன்லைனில் கிடைக்கிறது. புத்தகம், கோ மூலக் குறியீட்டைப் போலவே, படிக்க எளிதானது, நல்ல குறியீட்டு எடுத்துக்காட்டுகள் மற்றும் ஒரே அமர்வில் படிக்கக்கூடிய 150 பக்கங்களைக் கொண்டுள்ளது. இந்த எளிமை முதலில் புத்துணர்ச்சி அளிக்கிறது, குறிப்பாக அதிக சிக்கலான தொழில்நுட்பத்தால் நிரப்பப்பட்ட நிரலாக்க உலகில். ஆனால் இறுதியில், விரைவில் அல்லது பின்னர் சிந்தனை எழுகிறது: "இது உண்மையில் அப்படியா?"

Go இன் எளிமையே அதன் விற்பனைப் புள்ளி என்றும், பெரிய அணிகளில் அதிகபட்ச உற்பத்தித்திறனுக்காக மொழி வடிவமைக்கப்பட்டுள்ளது என்றும் கூகுள் கூறுகிறது, ஆனால் எனக்கு அதில் சந்தேகம் உள்ளது. விடுபட்ட அல்லது அதிக விவரமான அம்சங்கள் உள்ளன. டெவலப்பர்கள் மீது நம்பிக்கை இல்லாததால், அவர்களால் எதையும் சரியாகச் செய்ய முடியவில்லை என்ற அனுமானத்துடன். எளிமைக்கான இந்த விருப்பம் மொழியின் வடிவமைப்பாளர்களின் நனவான முடிவாகும், மேலும் அது ஏன் தேவைப்பட்டது என்பதை முழுமையாகப் புரிந்துகொள்வதற்கு, டெவலப்பர்களின் உந்துதலையும் அவர்கள் கோவில் எதைச் சாதிக்க முயற்சிக்கிறார்கள் என்பதையும் நாம் புரிந்து கொள்ள வேண்டும்.

அது ஏன் மிகவும் எளிமையாக செய்யப்பட்டது? இங்கே இரண்டு மேற்கோள்கள் உள்ளன ராப் பைக் (தோராயமாக: கோ மொழியின் இணை உருவாக்கியவர்களில் ஒருவர்):

இங்கே முக்கிய விஷயம் என்னவென்றால், எங்கள் புரோகிராமர்கள் (தோராயமாக: கூகுளர்கள்) ஆராய்ச்சியாளர்கள் அல்ல. அவர்கள், ஒரு விதியாக, மிகவும் இளமையாக இருக்கிறார்கள், படித்த பிறகு எங்களிடம் வருகிறார்கள், ஒருவேளை அவர்கள் ஜாவா, அல்லது சி/சி++ அல்லது பைதான் படித்திருக்கலாம். அவர்களால் ஒரு சிறந்த மொழியைப் புரிந்து கொள்ள முடியாது, ஆனால் அதே நேரத்தில் அவர்கள் நல்ல மென்பொருளை உருவாக்க வேண்டும் என்று நாங்கள் விரும்புகிறோம். அதனால்தான் அவர்களின் மொழி அவர்கள் புரிந்துகொள்ளவும் கற்றுக்கொள்ளவும் எளிதாக இருக்க வேண்டும்.
 
அவர் பரிச்சயமானவராக இருக்க வேண்டும், தோராயமாக சியைப் போலவே பேசுகிறார். கூகுளில் பணிபுரியும் புரோகிராமர்கள் தங்கள் பணியை ஆரம்பத்திலேயே தொடங்குகின்றனர் மற்றும் பெரும்பாலும் நடைமுறை மொழிகள், குறிப்பாக சி குடும்பத்தை நன்கு அறிந்தவர்கள். ஒரு புதிய நிரலாக்க மொழியில் விரைவான உற்பத்தித்திறன் தேவை என்பது மொழி மிகவும் தீவிரமானதாக இருக்கக்கூடாது என்பதாகும்.

என்ன? எனவே ராப் பைக் கூகுளில் உள்ள டெவலப்பர்கள் அவ்வளவு நல்லவர்கள் இல்லை என்று கூறுகிறார், அதனால்தான் அவர்கள் முட்டாள்களுக்காக ஒரு மொழியை உருவாக்கினார்கள் (தோராயமாக: ஊமையாக) அதனால் அவர்கள் ஏதாவது செய்ய முடியும். உங்கள் சொந்த சக ஊழியர்களைப் பற்றி என்ன வகையான திமிர்த்தனமான பார்வை? கூகிளின் டெவலப்பர்கள் பூமியில் உள்ள பிரகாசமான மற்றும் சிறந்தவர்களிடமிருந்து தேர்ந்தெடுக்கப்பட்டவர்கள் என்று நான் எப்போதும் நம்புவேன். நிச்சயமாக அவர்கள் கடினமான ஒன்றைக் கையாள முடியுமா?

அதிகப்படியான எளிமையின் கலைப்பொருட்கள்

எந்தவொரு வடிவமைப்பிலும் எளிமையாக இருப்பது ஒரு தகுதியான குறிக்கோள், மேலும் எளிமையான ஒன்றை உருவாக்க முயற்சிப்பது கடினம். இருப்பினும், சிக்கலான சிக்கல்களைத் தீர்க்க (அல்லது வெளிப்படுத்தவும்) முயற்சிக்கும் போது, ​​சில நேரங்களில் ஒரு சிக்கலான கருவி தேவைப்படுகிறது. சிக்கலான தன்மை மற்றும் நுணுக்கமானது ஒரு நிரலாக்க மொழியின் சிறந்த அம்சங்கள் அல்ல, ஆனால் ஒரு நடுத்தர நிலம் உள்ளது, இதில் மொழி எளிமையாக புரிந்துகொள்ளவும் பயன்படுத்தவும் கூடிய நேர்த்தியான சுருக்கங்களை உருவாக்க முடியும்.

மிகவும் வெளிப்படையானது அல்ல

எளிமைக்கான அதன் அர்ப்பணிப்பு காரணமாக, மற்ற மொழிகளில் இயற்கையாகக் கருதப்படும் கட்டுமானங்கள் Goவில் இல்லை. முதலில் இது ஒரு நல்ல யோசனையாகத் தோன்றலாம், ஆனால் நடைமுறையில் இது verbose code இல் விளைகிறது. இதற்கான காரணம் தெளிவாக இருக்க வேண்டும் - டெவலப்பர்கள் மற்றவர்களின் குறியீட்டைப் படிக்க எளிதாக இருக்க வேண்டும், ஆனால் உண்மையில் இந்த எளிமைப்படுத்தல்கள் வாசிப்புத்திறனை மட்டுமே பாதிக்கின்றன. 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 ஐ மேம்படுத்துவதற்கான ஒரு பிரபலமான பரிந்துரை பொதுவானது. அனைத்து தரவு வகைகளையும் ஆதரிக்க, தேவையற்ற குறியீட்டை நகலெடுப்பதைத் தவிர்க்க இது குறைந்தபட்சம் உதவும். எடுத்துக்காட்டாக, முழு எண்களின் பட்டியலைத் தொகுப்பதற்கான ஒரு செயல்பாடு, ஒவ்வொரு முழு எண் வகைக்கும் அதன் அடிப்படை செயல்பாட்டை நகலெடுத்து ஒட்டுவதைத் தவிர வேறு வழியில் செயல்படுத்த முடியாது; வேறு வழியில்லை:

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;
}

எளிய, நேர்த்தியான மற்றும் நேரடியாக புள்ளி. இங்கே பயன்படுத்தப்படும் செயல்பாடு reduce டெம்ப்ளேட் வகை மற்றும் முன்னறிவிப்புக்கு. ஆமாம், இது மீண்டும் 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 கட்டுரையிலிருந்து கடன் வாங்கப்பட்டது கோவில் உள்ள இடியோமேடிக் ஜெனரிக்ஸ் (தோராயமாக: என்னால் மொழிபெயர்ப்பைக் கண்டுபிடிக்க முடியவில்லை, இதற்கு நீங்கள் உதவினால் நான் மகிழ்ச்சியடைவேன்). சரி, அது idiomatic ஆக இருந்தால், நான் மொழியியல்லாத உதாரணத்தைப் பார்ப்பதை வெறுக்கிறேன். பயன்பாடு interface{} - ஒரு கேலிக்கூத்து, மற்றும் மொழியில் தட்டச்சு செய்வதைத் தவிர்ப்பதற்கு மட்டுமே இது தேவைப்படுகிறது. இது ஒரு வெற்று இடைமுகம் மற்றும் அனைத்து வகைகளும் இதை செயல்படுத்துகின்றன, அனைவருக்கும் முழுமையான சுதந்திரத்தை அனுமதிக்கிறது. நிரலாக்கத்தின் இந்த பாணி மிகவும் அசிங்கமானது, அது மட்டுமல்ல. இது போன்ற அக்ரோபாட்டிக் சாதனைகளுக்கு இயக்க நேர பிரதிபலிப்பு தேவைப்படுகிறது. ராப் பைக் கூட இதை துஷ்பிரயோகம் செய்யும் நபர்களை விரும்பவில்லை என்று அவர் தனது அறிக்கை ஒன்றில் குறிப்பிட்டுள்ளார்.

இது ஒரு சக்திவாய்ந்த கருவியாகும், இது எச்சரிக்கையுடன் பயன்படுத்தப்பட வேண்டும். கண்டிப்பாக தேவையில்லாமல் தவிர்க்கப்பட வேண்டும்.

நான் இந்த முட்டாள்தனத்திற்கு பதிலாக D டெம்ப்ளேட்களை எடுக்க விரும்புகிறேன். அதை எப்படி யாராலும் சொல்ல முடியும் interface{} மேலும் படிக்கக்கூடியதா அல்லது பாதுகாப்பான வகையா?

சார்பு நிர்வாகத்தின் துயரங்கள்

பிரபலமான ஹோஸ்டிங் வழங்குநர்களின் மேல் கட்டமைக்கப்பட்ட ஒரு உள்ளமைக்கப்பட்ட சார்பு அமைப்பு Go உள்ளது அறையானது. Go உடன் வரும் கருவிகள் இந்தச் சேவைகளைப் பற்றி அறிந்திருப்பதோடு, அவற்றிலிருந்து குறியீட்டைப் பதிவிறக்கவும், உருவாக்கவும் மற்றும் நிறுவவும் முடியும். இது நன்றாக இருந்தாலும், பதிப்பில் ஒரு பெரிய குறைபாடு உள்ளது! ஆம், Go கருவிகளைப் பயன்படுத்தி கிதுப் அல்லது பிட்பக்கெட் போன்ற சேவைகளிலிருந்து மூலக் குறியீட்டைப் பெறலாம் என்பது உண்மைதான், ஆனால் பதிப்பைக் குறிப்பிட முடியாது. பயனின் இழப்பில் மீண்டும் எளிமை. அத்தகைய முடிவின் தர்க்கத்தை என்னால் புரிந்து கொள்ள முடியவில்லை.

இந்தச் சிக்கலுக்கான தீர்வு குறித்த கேள்விகளைக் கேட்ட பிறகு, கோ மேம்பாட்டுக் குழு உருவாக்கியது மன்ற நூல், இந்தப் பிரச்சினையை அவர்கள் எப்படிச் சமாளிக்கப் போகிறார்கள் என்பதை கோடிட்டுக் காட்டியது. ஒரு நாள் உங்கள் திட்டத்தில் முழு களஞ்சியத்தையும் நகலெடுத்து அதை "அப்படியே" விட வேண்டும் என்பது அவர்களின் பரிந்துரை. என்ன நரகம் யோசிக்கிறார்கள்? கோ கிரியேட்டர்கள் புறக்கணித்து, மூலக் குறியீட்டை நகலெடுக்கும் சிறந்த டேக்கிங் மற்றும் பதிப்பு ஆதரவுடன் அற்புதமான பதிப்புக் கட்டுப்பாட்டு அமைப்புகள் எங்களிடம் உள்ளன.

Xi இலிருந்து கலாச்சார சாமான்கள்

என் கருத்துப்படி, கோ உருவாக்கப்பட்டது என்பது தங்கள் வாழ்நாள் முழுவதும் C ஐப் பயன்படுத்தியவர்களாலும், புதிதாக முயற்சி செய்ய விரும்பாதவர்களாலும் உருவாக்கப்பட்டது. கூடுதல் சக்கரங்கள் கொண்ட சி என மொழியை விவரிக்கலாம்(orig.: பயிற்சி சக்கரங்கள்) இணையான ஆதரவைத் தவிர, அதில் புதிய யோசனைகள் எதுவும் இல்லை (இது, அற்புதமானது) மற்றும் இது ஒரு அவமானம். நீங்கள் பயன்படுத்த முடியாத, நொண்டி மொழியில் சிறந்த இணைத்தன்மையைக் கொண்டிருக்கிறீர்கள்.

மற்றொரு பிரச்சனை என்னவென்றால், கோ என்பது ஒரு நடைமுறை மொழி (C இன் அமைதியான திகில் போன்றது). தொன்மையானதாகவும் காலாவதியானதாகவும் உணரும் நடைமுறை பாணியில் குறியீட்டை எழுதி முடிக்கிறீர்கள். பொருள் சார்ந்த நிரலாக்கம் ஒரு வெள்ளி புல்லட் அல்ல என்பதை நான் அறிவேன், ஆனால் விவரங்களை வகைகளாகச் சுருக்கி இணைத்து வழங்குவது நன்றாக இருக்கும்.

உங்கள் சொந்த நலனுக்காக எளிமை

கோ எளிமையானதாக வடிவமைக்கப்பட்டுள்ளது, அது அந்த இலக்கை அடையும். இது பழைய மொழியை டெம்ப்ளேட்டாகப் பயன்படுத்தி பலவீனமான புரோகிராமர்களுக்காக எழுதப்பட்டது. எளிமையான விஷயங்களைச் செய்வதற்கான எளிய கருவிகளுடன் இது முழுமையாக வருகிறது. இது படிக்க எளிதானது மற்றும் பயன்படுத்த எளிதானது.

இது மிகவும் வாய்மொழியானது, ஈர்க்க முடியாதது மற்றும் ஸ்மார்ட் புரோகிராமர்களுக்கு மோசமானது.

Спасибо மெர்சின்வால்ட் திருத்தங்களுக்கு

ஆதாரம்: www.habr.com