શા માટે ગો ડિઝાઇન સ્માર્ટ પ્રોગ્રામર્સ માટે ખરાબ છે

છેલ્લા મહિનાઓથી હું અમલીકરણ માટે Go નો ઉપયોગ કરી રહ્યો છું. કલ્પનાનો પુરાવો (આશરે: એક વિચારની કાર્યક્ષમતા ચકાસવા માટેનો કોડ) તેના મફત સમયમાં, આંશિક રીતે પ્રોગ્રામિંગ ભાષાનો અભ્યાસ કરવા માટે. પ્રોગ્રામ્સ પોતે ખૂબ જ સરળ છે અને આ લેખનો હેતુ નથી, પરંતુ ગોનો ઉપયોગ કરવાનો અનુભવ તેના વિશે થોડાક શબ્દોને પાત્ર છે. બનવાનું વચન આપે છે (આશરે: 2015 માં લખાયેલ લેખ) ગંભીર સ્કેલેબલ કોડ માટેની લોકપ્રિય ભાષા. આ ભાષા Google દ્વારા બનાવવામાં આવી હતી, જ્યાં તેનો સક્રિય ઉપયોગ થાય છે. બોટમ લાઇન, હું પ્રામાણિકપણે માનું છું કે ગો ભાષાની ડિઝાઇન સ્માર્ટ પ્રોગ્રામરો માટે ખરાબ છે.

નબળા પ્રોગ્રામરો માટે રચાયેલ છે?

ગો શીખવું ખૂબ જ સરળ છે, એટલું સરળ છે કે પરિચય મને એક સાંજે લઈ ગયો, જેના પછી હું પહેલેથી જ ઉત્પાદક રીતે કોડ કરી શક્યો. હું ગો શીખવા માટે વપરાયેલ પુસ્તક કહેવાય છે ગોમાં પ્રોગ્રામિંગનો પરિચય (સ્થાનાંતરણ), તે ઓનલાઈન ઉપલબ્ધ છે. આ પુસ્તક, ગો સોર્સ કોડની જેમ, વાંચવામાં સરળ છે, સારા કોડ ઉદાહરણો છે, અને લગભગ 150 પૃષ્ઠો ધરાવે છે જે એક બેઠકમાં વાંચી શકાય છે. આ સરળતા શરૂઆતમાં તાજગી આપે છે, ખાસ કરીને વધુ જટિલ ટેકનોલોજીથી ભરેલી પ્રોગ્રામિંગ દુનિયામાં. પરંતુ અંતે, વહેલા અથવા પછીના વિચારો ઉદ્ભવે છે: "શું આ ખરેખર આવું છે?"

Google દાવો કરે છે કે Go ની સરળતા એ તેનું વેચાણ બિંદુ છે અને ભાષા મોટી ટીમોમાં મહત્તમ ઉત્પાદકતા માટે ડિઝાઇન કરવામાં આવી છે, પરંતુ મને તેના પર શંકા છે. એવી સુવિધાઓ છે જે ક્યાં તો ખૂટે છે અથવા વધુ પડતી વિગતવાર છે. અને બધા વિકાસકર્તાઓમાં વિશ્વાસના અભાવને કારણે, એવી ધારણા સાથે કે તેઓ કંઈપણ યોગ્ય કરી શકતા નથી. સરળતા માટેની આ ઇચ્છા એ ભાષાના ડિઝાઇનરો દ્વારા એક સભાન નિર્ણય હતો, અને શા માટે તેની જરૂર હતી તે સંપૂર્ણ રીતે સમજવા માટે, આપણે વિકાસકર્તાઓની પ્રેરણા અને તેઓ Go માં શું પ્રાપ્ત કરવાનો પ્રયાસ કરી રહ્યા હતા તે સમજવું જોઈએ.

તો શા માટે તેને આટલું સરળ બનાવવામાં આવ્યું? અહીં કેટલાક અવતરણો છે રોબ પાઈક (આશરે: ગો ભાષાના સહ-નિર્માતાઓમાંના એક):

અહીં મુખ્ય મુદ્દો એ છે કે અમારા પ્રોગ્રામરો (આશરે: Googlers) સંશોધકો નથી. તેઓ, એક નિયમ તરીકે, તદ્દન યુવાન છે, અભ્યાસ કર્યા પછી અમારી પાસે આવે છે, કદાચ તેઓએ Java, અથવા C/C++, અથવા Python નો અભ્યાસ કર્યો હોય. તેઓ સારી ભાષા સમજી શકતા નથી, પરંતુ તે જ સમયે અમે ઇચ્છીએ છીએ કે તેઓ સારા સોફ્ટવેર બનાવે. તેથી જ તેમની ભાષા સમજવા અને શીખવા માટે સરળ હોવી જોઈએ.
 
તે પરિચિત હોવા જોઈએ, લગભગ સી જેવું જ બોલતા. Google પર કામ કરતા પ્રોગ્રામરો તેમની કારકિર્દીની શરૂઆત વહેલી શરૂ કરે છે અને મોટે ભાગે પ્રક્રિયાગત ભાષાઓથી પરિચિત હોય છે, ખાસ કરીને C કુટુંબ. નવી પ્રોગ્રામિંગ ભાષામાં ઝડપી ઉત્પાદકતા માટેની આવશ્યકતાનો અર્થ એ છે કે ભાષા ખૂબ આમૂલ ન હોવી જોઈએ.

શું? તેથી રોબ પાઈક મૂળભૂત રીતે કહે છે કે Google ના વિકાસકર્તાઓ એટલા સારા નથી, તેથી જ તેઓએ મૂર્ખ લોકો માટે ભાષા બનાવી છે (આશરે: ડમ્બ ડાઉન) જેથી તેઓ કંઈક કરી શકે. તમારા પોતાના સાથીદારો પર કેવો ઘમંડી દેખાવ? હું હંમેશા માનું છું કે Google ના વિકાસકર્તાઓ પૃથ્વી પરના સૌથી તેજસ્વી અને શ્રેષ્ઠમાંથી પસંદ કરવામાં આવ્યા છે. ચોક્કસ તેઓ કંઈક વધુ મુશ્કેલ હેન્ડલ કરી શકે છે?

અતિશય સરળતાની કલાકૃતિઓ

કોઈપણ ડિઝાઇનમાં સરળ બનવું એ યોગ્ય ધ્યેય છે, અને કંઈક સરળ બનાવવાનો પ્રયાસ કરવો મુશ્કેલ છે. જો કે, જ્યારે જટિલ સમસ્યાઓ ઉકેલવાનો (અથવા વ્યક્ત) કરવાનો પ્રયાસ કરવામાં આવે છે, ત્યારે કેટલીકવાર એક જટિલ સાધનની જરૂર પડે છે. જટિલતા અને જટિલતા એ પ્રોગ્રામિંગ ભાષાની શ્રેષ્ઠ લાક્ષણિકતાઓ નથી, પરંતુ એક મધ્યમ ભૂમિ છે જેમાં ભાષા ભવ્ય અમૂર્તતા બનાવી શકે છે જે સમજવા અને ઉપયોગમાં સરળ છે.

બહુ અભિવ્યક્ત નથી

સરળતા પ્રત્યેની તેની પ્રતિબદ્ધતાને કારણે, ગોમાં એવી રચનાઓનો અભાવ છે જે અન્ય ભાષાઓમાં કુદરતી માનવામાં આવે છે. આ શરૂઆતમાં સારો વિચાર લાગે છે, પરંતુ વ્યવહારમાં તે વર્બોઝ કોડમાં પરિણમે છે. આનું કારણ સ્પષ્ટ હોવું જોઈએ - વિકાસકર્તાઓ માટે અન્ય લોકોના કોડ વાંચવા માટે તે સરળ હોવું જરૂરી છે, પરંતુ હકીકતમાં આ સરળીકરણો ફક્ત વાંચનક્ષમતાને નુકસાન પહોંચાડે છે. 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)
}

જો કે આ કોડ શક્ય તેટલો સામાન્ય બનવાનો પણ પ્રયાસ કરે છે, ગોની ફરજિયાત વર્બોસિટી આડે આવે છે, અને પરિણામે, એક સરળ સમસ્યાને ઉકેલવાથી કોડની મોટી માત્રામાં પરિણમે છે.

અહીં, ઉદાહરણ તરીકે, માં સમાન સમસ્યાનો ઉકેલ છે 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);
    }
}

અને હવે કોણ વધુ વાંચવા યોગ્ય છે? હું મારો મત ડીને આપીશ. તેનો કોડ વધુ વાંચવા યોગ્ય છે કારણ કે તે ક્રિયાઓનું વધુ સ્પષ્ટ વર્ણન કરે છે. ડી વધુ જટિલ ખ્યાલોનો ઉપયોગ કરે છે (આશરે: વૈકલ્પિક કાર્ય કૉલ и નમૂનાઓ) 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))
}

અને આ ઉદાહરણ સહી કરેલ પ્રકારો માટે પણ કામ કરતું નથી. આ અભિગમ સંપૂર્ણપણે તમારી જાતને પુનરાવર્તન ન કરવાના સિદ્ધાંતનું ઉલ્લંઘન કરે છે (સૂકા), સૌથી પ્રસિદ્ધ અને સ્પષ્ટ સિદ્ધાંતોમાંનું એક, જેને અવગણવું કે જે ઘણી ભૂલોનો સ્ત્રોત છે. ગો આવું કેમ કરે છે? ભાષાનું આ એક ભયંકર પાસું છે.

ડી પર સમાન ઉદાહરણ:

import std.stdio;
import std.algorithm;

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

સરળ, ભવ્ય અને સીધા મુદ્દા પર. અહીં વપરાયેલ કાર્ય છે reduce નમૂના પ્રકાર અને આગાહી માટે. હા, ગો વર્ઝન કરતાં આ ફરીથી વધુ જટિલ છે, પરંતુ સ્માર્ટ પ્રોગ્રામરો માટે સમજવું એટલું મુશ્કેલ નથી. કયું ઉદાહરણ જાળવવામાં સરળ અને વાંચવામાં સરળ છે?

સરળ પ્રકારની સિસ્ટમ બાયપાસ

હું કલ્પના કરું છું કે ગો પ્રોગ્રામરો આ વાંચીને મોં પર ફીણ આવશે અને ચીસો પાડશે, "તમે ખોટું કરી રહ્યાં છો!" ઠીક છે, સામાન્ય કાર્ય અને પ્રકારો બનાવવાની બીજી રીત છે, પરંતુ તે સંપૂર્ણપણે ટાઇપ સિસ્ટમને તોડે છે!

સમસ્યાની આસપાસ કામ કરવા માટે મૂર્ખ ભાષા ફિક્સના આ ઉદાહરણ પર એક નજર નાખો:

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{} - એક પ્રહસન, અને ભાષામાં તે ફક્ત ટાઇપિંગને બાયપાસ કરવા માટે જરૂરી છે. આ એક ખાલી ઈન્ટરફેસ છે અને તમામ પ્રકારો તેનો અમલ કરે છે, દરેકને સંપૂર્ણ સ્વતંત્રતા આપે છે. પ્રોગ્રામિંગની આ શૈલી ભયંકર નીચ છે, અને તે બધુ જ નથી. આના જેવા એક્રોબેટિક પરાક્રમ માટે રનટાઇમ રિફ્લેક્શનનો ઉપયોગ જરૂરી છે. રોબ પાઈકને પણ આનો દુરુપયોગ કરનાર વ્યક્તિઓ પસંદ નથી, જેમ કે તેણે તેના એક અહેવાલમાં ઉલ્લેખ કર્યો છે.

આ એક શક્તિશાળી સાધન છે જેનો ઉપયોગ સાવધાની સાથે થવો જોઈએ. સખત આવશ્યકતા સિવાય તેને ટાળવું જોઈએ.

હું આ નોનસેન્સને બદલે ડી ટેમ્પલેટ્સ લઈશ. એવું કોઈ કેવી રીતે કહી શકે interface{} વધુ વાંચવા યોગ્ય અથવા તો ટાઇપ સુરક્ષિત?

અવલંબન વ્યવસ્થાપનની મુશ્કેલીઓ

ગોમાં લોકપ્રિય હોસ્ટિંગ પ્રદાતાઓની ટોચ પર બિલ્ટ-ઇન ડિપેન્ડન્સી સિસ્ટમ છે વીસીએસ. ગો સાથે આવતા સાધનો આ સેવાઓ વિશે જાણે છે અને તેમાંથી કોડ ડાઉનલોડ, બિલ્ડ અને ઇન્સ્ટોલ કરી શકે છે. જ્યારે આ મહાન છે, ત્યાં આવૃત્તિ સાથે એક મોટી ખામી છે! હા, એ સાચું છે કે તમે ગો ટૂલ્સનો ઉપયોગ કરીને ગીથબ અથવા બીટબકેટ જેવી સેવાઓમાંથી સ્રોત કોડ મેળવી શકો છો, પરંતુ તમે સંસ્કરણનો ઉલ્લેખ કરી શકતા નથી. અને ફરીથી ઉપયોગિતાના ભોગે સરળતા. હું આવા નિર્ણયનો તર્ક સમજી શકતો નથી.

આ સમસ્યાના ઉકેલ વિશે પ્રશ્નો પૂછ્યા પછી, ગો ડેવલપમેન્ટ ટીમ બનાવી ફોરમ થ્રેડ, જે દર્શાવે છે કે તેઓ આ મુદ્દાને કેવી રીતે પાર પાડશે. તેમની ભલામણ એ હતી કે એક દિવસ તમારા પ્રોજેક્ટમાં સમગ્ર રીપોઝીટરીની નકલ કરો અને તેને "જેમ છે તેમ" છોડી દો. તેઓ શું વિચારી રહ્યા છે? અમારી પાસે અદ્ભુત ટેગિંગ અને વર્ઝન સપોર્ટ સાથે અદ્ભુત વર્ઝન કંટ્રોલ સિસ્ટમ્સ છે જેને Go સર્જકો અવગણે છે અને માત્ર સોર્સ કોડની કૉપિ કરે છે.

ક્ઝી તરફથી સાંસ્કૃતિક સામાન

મારા મતે, ગો એવા લોકો દ્વારા વિકસાવવામાં આવ્યું હતું જેમણે આખી જીંદગી C નો ઉપયોગ કર્યો હતો અને જેઓ કંઈક નવું કરવાનો પ્રયાસ કરવા માંગતા ન હતા. વધારાના વ્હીલ્સ સાથે ભાષાને C તરીકે વર્ણવી શકાય છે(મૂળ: તાલીમ વ્હીલ્સ). તેમાં કોઈ નવા વિચારો નથી, સમાંતરતાના સમર્થન સિવાય (જે, માર્ગ દ્વારા, અદ્ભુત છે) અને આ શરમજનક છે. તમારી પાસે ભાગ્યે જ ઉપયોગી, લંગડી ભાષામાં ઉત્તમ સમાનતા છે.

બીજી સર્જાતી સમસ્યા એ છે કે ગો એક પ્રક્રિયાગત ભાષા છે (જેમ કે સીની સાયલન્ટ હોરર). તમે પ્રક્રિયાગત શૈલીમાં કોડ લખવાનું સમાપ્ત કરો છો જે પ્રાચીન અને જૂનું લાગે છે. હું જાણું છું કે ઑબ્જેક્ટ ઓરિએન્ટેડ પ્રોગ્રામિંગ એ સિલ્વર બુલેટ નથી, પરંતુ વિગતોને પ્રકારોમાં અમૂર્ત કરવામાં અને એન્કેપ્સ્યુલેશન પ્રદાન કરવા માટે સક્ષમ બનવું તે સરસ રહેશે.

તમારા પોતાના ફાયદા માટે સરળતા

ગોને સરળ બનાવવા માટે ડિઝાઇન કરવામાં આવી હતી અને તે તે લક્ષ્યમાં સફળ થાય છે. તે નબળા પ્રોગ્રામરો માટે લખવામાં આવ્યું હતું, ટેમ્પલેટ તરીકે જૂની ભાષાનો ઉપયોગ કરીને. તે સરળ વસ્તુઓ કરવા માટે સરળ સાધનો સાથે પૂર્ણ થાય છે. તે વાંચવામાં સરળ અને ઉપયોગમાં સરળ છે.

તે સ્માર્ટ પ્રોગ્રામરો માટે અત્યંત વર્બોઝ, અપ્રભાવી અને ખરાબ છે.

Спасибо મેર્સિનવાલ્ડ સંપાદનો માટે

સોર્સ: www.habr.com