സ്മാർട്ട് പ്രോഗ്രാമർമാർക്ക് എന്തുകൊണ്ട് ഗോ ഡിസൈൻ മോശമാണ്

കഴിഞ്ഞ മാസങ്ങളിൽ ഞാൻ നടപ്പിലാക്കലുകൾക്കായി Go ഉപയോഗിക്കുന്നു. ആശയത്തിന്റെ തെളിവ് (ഏകദേശം.: ഒരു ആശയത്തിന്റെ പ്രവർത്തനക്ഷമത പരിശോധിക്കുന്നതിനുള്ള കോഡ്) അവന്റെ ഒഴിവുസമയങ്ങളിൽ, ഭാഗികമായി പ്രോഗ്രാമിംഗ് ഭാഷ പഠിക്കാൻ. പ്രോഗ്രാമുകൾ തന്നെ വളരെ ലളിതവും ഈ ലേഖനത്തിന്റെ ഉദ്ദേശ്യവുമല്ല, എന്നാൽ Go ഉപയോഗിക്കുന്നതിന്റെ അനുഭവം അതിനെക്കുറിച്ച് കുറച്ച് വാക്കുകൾ അർഹിക്കുന്നു. പോകുമെന്ന് വാഗ്ദാനം ചെയ്യുന്നു (ഏകദേശം.: 2015-ൽ എഴുതിയ ലേഖനം) ഗുരുതരമായ സ്കേലബിൾ കോഡിനായി ഒരു ജനപ്രിയ ഭാഷ. ഭാഷ സൃഷ്ടിച്ചത് Google ആണ്, അവിടെ അത് സജീവമായി ഉപയോഗിക്കുന്നു. അടിവരയിട്ട്, ഗോ ഭാഷയുടെ രൂപകൽപ്പന സ്മാർട്ട് പ്രോഗ്രാമർമാർക്ക് മോശമാണെന്ന് ഞാൻ സത്യസന്ധമായി കരുതുന്നു.

ദുർബലമായ പ്രോഗ്രാമർമാർക്കായി രൂപകൽപ്പന ചെയ്‌തിട്ടുണ്ടോ?

ഗോ പഠിക്കാൻ വളരെ എളുപ്പമാണ്, വളരെ എളുപ്പമാണ് ആമുഖം ഒരു സായാഹ്നത്തിൽ എന്നെ കൊണ്ടുപോയി, അതിനുശേഷം എനിക്ക് ഇതിനകം തന്നെ ഉൽപ്പാദനക്ഷമമായി കോഡ് ചെയ്യാൻ കഴിയും. ഞാൻ ഗോ പഠിച്ചിരുന്ന പുസ്തകത്തിന്റെ പേര് Go-ലെ പ്രോഗ്രാമിംഗിന് ഒരു ആമുഖം (വിവർത്തനം), ഇത് ഓൺലൈനിൽ ലഭ്യമാണ്. Go സോഴ്സ് കോഡ് പോലെ തന്നെ ഈ പുസ്തകം വായിക്കാൻ എളുപ്പമാണ്, നല്ല കോഡ് ഉദാഹരണങ്ങൾ ഉണ്ട്, കൂടാതെ ഒറ്റയിരിപ്പിൽ വായിക്കാൻ കഴിയുന്ന 150 പേജുകൾ അടങ്ങിയിരിക്കുന്നു. ഈ ലാളിത്യം ആദ്യം ഉന്മേഷദായകമാണ്, പ്രത്യേകിച്ച് അതിസങ്കീർണ്ണമായ സാങ്കേതികവിദ്യകൾ നിറഞ്ഞ ഒരു പ്രോഗ്രാമിംഗ് ലോകത്ത്. എന്നാൽ അവസാനം, താമസിയാതെ അല്ലെങ്കിൽ പിന്നീട് ചിന്ത ഉയർന്നുവരുന്നു: "ഇത് ശരിക്കും അങ്ങനെയാണോ?"

Go- യുടെ ലാളിത്യമാണ് അതിന്റെ വിൽപ്പന കേന്ദ്രം എന്ന് Google അവകാശപ്പെടുന്നു, വലിയ ടീമുകളിൽ പരമാവധി ഉൽപ്പാദനക്ഷമതയ്‌ക്കായി ഭാഷ രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു, പക്ഷേ എനിക്ക് സംശയമുണ്ട്. നഷ്‌ടമായതോ അമിതമായി വിശദമാക്കിയതോ ആയ സവിശേഷതകൾ ഉണ്ട്. ഡെവലപ്പർമാരിൽ വിശ്വാസക്കുറവ് കാരണം, അവർക്ക് ഒന്നും ശരിയായി ചെയ്യാൻ കഴിയുന്നില്ല എന്ന അനുമാനത്തോടെ. ലാളിത്യത്തിനായുള്ള ഈ ആഗ്രഹം ഭാഷയുടെ ഡിസൈനർമാരുടെ ബോധപൂർവമായ തീരുമാനമായിരുന്നു, അത് എന്തിനാണ് ആവശ്യമായി വന്നതെന്ന് പൂർണ്ണമായി മനസിലാക്കാൻ, ഡെവലപ്പർമാരുടെ പ്രചോദനവും അവർ Go-യിൽ എന്താണ് നേടാൻ ശ്രമിക്കുന്നതെന്നും നമ്മൾ മനസ്സിലാക്കണം.

പിന്നെ എന്തിനാണ് ഇത് ഇത്ര ലളിതമാക്കിയത്? ഇവിടെ ചില ഉദ്ധരണികൾ ഉണ്ട് റോബ് പൈക്ക് (ഏകദേശം.: ഗോ ഭാഷയുടെ സഹ-സ്രഷ്ടാക്കളിൽ ഒരാൾ):

ഇവിടെ പ്രധാന കാര്യം ഞങ്ങളുടെ പ്രോഗ്രാമർമാർ (ഏകദേശം.: ഗൂഗിളർമാർ) ഗവേഷകരല്ല. അവർ, ചട്ടം പോലെ, വളരെ ചെറുപ്പമാണ്, പഠിച്ചതിന് ശേഷം ഞങ്ങളുടെ അടുത്തേക്ക് വരുന്നു, ഒരുപക്ഷേ അവർ ജാവ, അല്ലെങ്കിൽ സി / സി ++ അല്ലെങ്കിൽ പൈത്തൺ പഠിച്ചു. അവർക്ക് മികച്ച ഭാഷ മനസ്സിലാക്കാൻ കഴിയില്ല, എന്നാൽ അതേ സമയം അവർ നല്ല സോഫ്റ്റ്‌വെയർ സൃഷ്ടിക്കണമെന്ന് ഞങ്ങൾ ആഗ്രഹിക്കുന്നു. അതുകൊണ്ടാണ് അവരുടെ ഭാഷ അവർക്ക് മനസ്സിലാക്കാനും പഠിക്കാനും എളുപ്പമുള്ളതായിരിക്കണം.
 
അവൻ പരിചിതനായിരിക്കണം, ഏകദേശം പറഞ്ഞാൽ സി. ഗൂഗിളിൽ പ്രവർത്തിക്കുന്ന പ്രോഗ്രാമർമാർ അവരുടെ കരിയർ നേരത്തെ ആരംഭിക്കുകയും നടപടിക്രമ ഭാഷകൾ, പ്രത്യേകിച്ച് സി ഫാമിലിയുമായി പരിചയപ്പെടുകയും ചെയ്യുന്നു. ഒരു പുതിയ പ്രോഗ്രാമിംഗ് ഭാഷയിൽ ദ്രുത ഉൽപ്പാദനക്ഷമതയുടെ ആവശ്യകത അർത്ഥമാക്കുന്നത് ഭാഷ വളരെ സമൂലമായിരിക്കരുത് എന്നാണ്.

എന്ത്? ഗൂഗിളിലെ ഡെവലപ്പർമാർ അത്ര നല്ലവരല്ല എന്നാണ് റോബ് പൈക്ക് അടിസ്ഥാനപരമായി പറയുന്നത്, അതുകൊണ്ടാണ് അവർ വിഡ്ഢികൾക്കായി ഒരു ഭാഷ സൃഷ്ടിച്ചത് (ഏകദേശം.: ഊമയായി) അങ്ങനെ അവർക്ക് എന്തെങ്കിലും ചെയ്യാൻ കഴിയും. സ്വന്തം സഹപ്രവർത്തകരോട് എന്ത് ധിക്കാരപരമായ നോട്ടം? ഗൂഗിളിന്റെ ഡെവലപ്പർമാർ ഭൂമിയിലെ ഏറ്റവും തിളക്കമുള്ളവരിൽ നിന്നും മികച്ചവരിൽ നിന്നും തിരഞ്ഞെടുക്കപ്പെട്ടവരാണെന്ന് ഞാൻ എപ്പോഴും വിശ്വസിക്കുന്നു. തീർച്ചയായും അവർക്ക് കൂടുതൽ ബുദ്ധിമുട്ടുള്ള എന്തെങ്കിലും കൈകാര്യം ചെയ്യാൻ കഴിയുമോ?

അമിതമായ ലാളിത്യത്തിന്റെ കലാരൂപങ്ങൾ

ലളിതമാകുക എന്നത് ഏതൊരു രൂപകൽപ്പനയിലും യോഗ്യമായ ഒരു ലക്ഷ്യമാണ്, ലളിതമായ എന്തെങ്കിലും ചെയ്യാൻ ശ്രമിക്കുന്നത് ബുദ്ധിമുട്ടാണ്. എന്നിരുന്നാലും, സങ്കീർണ്ണമായ പ്രശ്നങ്ങൾ പരിഹരിക്കാൻ (അല്ലെങ്കിൽ പോലും) ശ്രമിക്കുമ്പോൾ, ചിലപ്പോൾ സങ്കീർണ്ണമായ ഒരു ഉപകരണം ആവശ്യമാണ്. സങ്കീർണ്ണതയും സങ്കീർണ്ണതയും ഒരു പ്രോഗ്രാമിംഗ് ഭാഷയുടെ മികച്ച സവിശേഷതകളല്ല, എന്നാൽ ഭാഷയ്ക്ക് എളുപ്പത്തിൽ മനസ്സിലാക്കാനും ഉപയോഗിക്കാനും കഴിയുന്ന മനോഹരമായ അമൂർത്തങ്ങൾ സൃഷ്ടിക്കാൻ കഴിയുന്ന ഒരു മധ്യനിരയുണ്ട്.

വളരെ പ്രകടമല്ല

ലാളിത്യത്തോടുള്ള പ്രതിബദ്ധത നിമിത്തം, മറ്റ് ഭാഷകളിൽ സ്വാഭാവികമെന്ന് കരുതപ്പെടുന്ന നിർമ്മിതികൾ 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);
    }
}

ഇപ്പോൾ ആരാണ് കൂടുതൽ വായിക്കാൻ കഴിയുന്നത്? ഞാൻ എന്റെ വോട്ട് ഡിക്ക് നൽകും. അവൻ പ്രവർത്തനങ്ങൾ കൂടുതൽ വ്യക്തമായി വിവരിക്കുന്നതിനാൽ അദ്ദേഹത്തിന്റെ കോഡ് കൂടുതൽ വായിക്കാൻ കഴിയും. ഡി കൂടുതൽ സങ്കീർണ്ണമായ ആശയങ്ങൾ ഉപയോഗിക്കുന്നു (ഏകദേശം.: ഇതര ഫംഗ്ഷൻ കോൾ и ടെംപ്ലേറ്റുകൾ) ഗോ ഉദാഹരണത്തേക്കാൾ, എന്നാൽ അവ മനസ്സിലാക്കുന്നതിൽ സങ്കീർണ്ണമായ ഒന്നും തന്നെയില്ല.

നരകം പകർത്തുക

ഗോ മെച്ചപ്പെടുത്തുന്നതിനുള്ള ഒരു ജനപ്രിയ നിർദ്ദേശം സാമാന്യതയാണ്. എല്ലാ ഡാറ്റാ തരങ്ങളെയും പിന്തുണയ്‌ക്കുന്നതിന് കോഡ് അനാവശ്യമായി പകർത്തുന്നത് ഒഴിവാക്കാൻ ഇത് സഹായിക്കും. ഉദാഹരണത്തിന്, പൂർണ്ണസംഖ്യകളുടെ ഒരു ലിസ്റ്റ് സംഗ്രഹിക്കുന്നതിനുള്ള ഒരു ഫംഗ്‌ഷൻ, ഓരോ പൂർണ്ണസംഖ്യ തരത്തിനും അതിന്റെ അടിസ്ഥാന ഫംഗ്‌ഷൻ കോപ്പി-പേസ്റ്റ് ചെയ്യുന്നതല്ലാതെ മറ്റൊരു വിധത്തിലും നടപ്പിലാക്കാൻ കഴിയില്ല; മറ്റൊരു മാർഗവുമില്ല:

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 ടെംപ്ലേറ്റ് തരത്തിനും പ്രവചനത്തിനും. അതെ, ഇത് വീണ്ടും 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 ലേഖനത്തിൽ നിന്ന് കടമെടുത്തതാണ് ഗോയിലെ ഇഡിയൊമാറ്റിക് ജനറിക്‌സ് (ഏകദേശം.: എനിക്ക് വിവർത്തനം കണ്ടെത്താൻ കഴിഞ്ഞില്ല, നിങ്ങൾ ഇത് സഹായിച്ചാൽ ഞാൻ സന്തോഷിക്കും). ശരി, ഇത് ഭാഷാപരമായതാണെങ്കിൽ, ഭാഷാഭേദമില്ലാത്ത ഒരു ഉദാഹരണം കാണാൻ ഞാൻ വെറുക്കുന്നു. ഉപയോഗം interface{} - ഒരു പ്രഹസനം, ഭാഷയിൽ ഇത് ടൈപ്പിംഗ് മറികടക്കാൻ മാത്രമേ ആവശ്യമുള്ളൂ. ഇതൊരു ശൂന്യമായ ഇന്റർഫേസാണ്, എല്ലാ തരത്തിലും ഇത് നടപ്പിലാക്കുന്നു, എല്ലാവർക്കും പൂർണ്ണ സ്വാതന്ത്ര്യം അനുവദിക്കുന്നു. ഈ പ്രോഗ്രാമിംഗ് ശൈലി ഭയങ്കര വൃത്തികെട്ടതാണ്, മാത്രമല്ല. ഇതുപോലുള്ള അക്രോബാറ്റിക് ഫീറ്റുകൾക്ക് റൺടൈം പ്രതിഫലനം ആവശ്യമാണ്. റോബ് പൈക്ക് പോലും ഇത് ദുരുപയോഗം ചെയ്യുന്ന വ്യക്തികളെ ഇഷ്ടപ്പെടുന്നില്ല, അദ്ദേഹം തന്റെ റിപ്പോർട്ടുകളിലൊന്നിൽ സൂചിപ്പിച്ചതുപോലെ.

ജാഗ്രതയോടെ ഉപയോഗിക്കേണ്ട ശക്തമായ ഉപകരണമാണിത്. കർശനമായി ആവശ്യമില്ലെങ്കിൽ അത് ഒഴിവാക്കണം.

ഈ അസംബന്ധത്തിന് പകരം ഞാൻ D ടെംപ്ലേറ്റുകൾ എടുക്കും. ആർക്കെങ്കിലും അത് എങ്ങനെ പറയാൻ കഴിയും interface{} കൂടുതൽ വായിക്കാനാകുന്നതോ സുരക്ഷിതമായി ടൈപ്പ് ചെയ്യുന്നതോ?

ആശ്രിതത്വ മാനേജ്മെന്റിന്റെ ദുരിതങ്ങൾ

ജനപ്രിയ ഹോസ്റ്റിംഗ് ദാതാക്കളുടെ മുകളിൽ നിർമ്മിച്ച ഒരു ബിൽറ്റ്-ഇൻ ഡിപൻഡൻസി സിസ്റ്റം Go-യ്ക്ക് ഉണ്ട് വി.സി.എസ്. Go-യ്‌ക്കൊപ്പം വരുന്ന ടൂളുകൾക്ക് ഈ സേവനങ്ങളെക്കുറിച്ച് അറിയാം, അവയിൽ നിന്ന് ഒറ്റയടിക്ക് കോഡ് ഡൗൺലോഡ് ചെയ്യാനും നിർമ്മിക്കാനും ഇൻസ്റ്റാൾ ചെയ്യാനും കഴിയും. ഇത് മികച്ചതാണെങ്കിലും, പതിപ്പിൽ ഒരു പ്രധാന പോരായ്മയുണ്ട്! അതെ, Go ടൂളുകൾ ഉപയോഗിച്ച് github അല്ലെങ്കിൽ bitbucket പോലുള്ള സേവനങ്ങളിൽ നിന്ന് നിങ്ങൾക്ക് സോഴ്സ് കോഡ് ലഭിക്കുമെന്നത് ശരിയാണ്, എന്നാൽ നിങ്ങൾക്ക് പതിപ്പ് വ്യക്തമാക്കാൻ കഴിയില്ല. ഉപയോഗത്തിന്റെ ചെലവിൽ വീണ്ടും ലാളിത്യം. അത്തരമൊരു തീരുമാനത്തിന്റെ യുക്തി എനിക്ക് മനസ്സിലാക്കാൻ കഴിയുന്നില്ല.

ഈ പ്രശ്‌നത്തിനുള്ള പരിഹാരത്തെക്കുറിച്ച് ചോദ്യങ്ങൾ ചോദിച്ചതിന് ശേഷം, ഗോ ഡെവലപ്‌മെന്റ് ടീം സൃഷ്‌ടിച്ചു ഫോറം ത്രെഡ്, അവർ ഈ പ്രശ്‌നത്തെ എങ്ങനെ നേരിടാൻ പോകുന്നുവെന്ന് ഇത് വിശദീകരിച്ചു. ഒരു ദിവസം നിങ്ങളുടെ പ്രോജക്റ്റിലേക്ക് മുഴുവൻ ശേഖരണവും പകർത്തി "അതുപോലെ തന്നെ" വിടുക എന്നതായിരുന്നു അവരുടെ ശുപാർശ. എന്താണ് അവർ ചിന്തിക്കുന്നത്? Go സ്രഷ്‌ടാക്കൾ അവഗണിക്കുകയും സോഴ്‌സ് കോഡ് പകർത്തുകയും ചെയ്യുന്ന മികച്ച ടാഗിംഗും പതിപ്പ് പിന്തുണയുമുള്ള അതിശയകരമായ പതിപ്പ് നിയന്ത്രണ സംവിധാനങ്ങൾ ഞങ്ങളുടെ പക്കലുണ്ട്.

Xi-ൽ നിന്നുള്ള സാംസ്കാരിക ലഗേജ്

എന്റെ അഭിപ്രായത്തിൽ, ജീവിതകാലം മുഴുവൻ സി ഉപയോഗിച്ചവരും പുതിയ എന്തെങ്കിലും പരീക്ഷിക്കാൻ ആഗ്രഹിക്കാത്തവരും ചേർന്നാണ് ഗോ വികസിപ്പിച്ചെടുത്തത്. ഭാഷയെ അധിക ചക്രങ്ങളുള്ള സി എന്ന് വിശേഷിപ്പിക്കാം(ഒറിഗ്.: പരിശീലന ചക്രങ്ങൾ). സമാന്തരത്വത്തിനുള്ള പിന്തുണ ഒഴികെ അതിൽ പുതിയ ആശയങ്ങളൊന്നുമില്ല (ഇത് അതിശയകരമാണ്) ഇത് ലജ്ജാകരമാണ്. കഷ്ടിച്ച് ഉപയോഗിക്കാവുന്ന, മുടന്തൻ ഭാഷയിൽ നിങ്ങൾക്ക് മികച്ച സമാന്തരതയുണ്ട്.

ഗോ ഒരു നടപടിക്രമ ഭാഷയാണ് (സി യുടെ നിശബ്ദ ഭീകരത പോലെ) എന്നതാണ് മറ്റൊരു പ്രശ്‌നം. പ്രാചീനവും കാലഹരണപ്പെട്ടതുമായി തോന്നുന്ന ഒരു നടപടിക്രമ ശൈലിയിൽ നിങ്ങൾ കോഡ് എഴുതുന്നു. ഒബ്‌ജക്‌റ്റ് ഓറിയന്റഡ് പ്രോഗ്രാമിംഗ് ഒരു സിൽവർ ബുള്ളറ്റല്ലെന്ന് എനിക്കറിയാം, എന്നാൽ വിശദാംശങ്ങളെ തരങ്ങളായി സംഗ്രഹിക്കാനും എൻക്യാപ്‌സുലേഷൻ നൽകാനും കഴിയുന്നത് വളരെ മികച്ചതായിരിക്കും.

നിങ്ങളുടെ സ്വന്തം നേട്ടത്തിനായി ലാളിത്യം

Go രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നത് ലളിതമാണ്, അത് ആ ലക്ഷ്യത്തിൽ വിജയിക്കുന്നു. ദുർബലമായ പ്രോഗ്രാമർമാർക്കായി ഇത് എഴുതിയതാണ്, ഒരു പഴയ ഭാഷ ഒരു ടെംപ്ലേറ്റായി ഉപയോഗിച്ചു. ലളിതമായ കാര്യങ്ങൾ ചെയ്യുന്നതിനുള്ള ലളിതമായ ഉപകരണങ്ങൾ ഉപയോഗിച്ച് ഇത് പൂർണ്ണമായി വരുന്നു. ഇത് വായിക്കാൻ എളുപ്പവും ഉപയോഗിക്കാൻ എളുപ്പവുമാണ്.

ഇത് അങ്ങേയറ്റം വാചാടോപമുള്ളതും ആകർഷകമല്ലാത്തതും സ്മാർട്ട് പ്രോഗ്രാമർമാർക്ക് മോശവുമാണ്.

Спасибо മെർസിൻവാൾഡ് എഡിറ്റുകൾക്കായി

അവലംബം: www.habr.com