આ લેખ અગાઉ પ્રકાશિત થયેલા પ્રતિભાવ તરીકે લખવામાં આવ્યો હતો એન્ટિપોડિયન લેખ.

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

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

નબળા લોકો સમસ્યાઓ વિશે વાત કરે છે. વિચારો અને સપના વિશે મજબૂત ચર્ચા...

ગો શીખવા માટે ખૂબ જ સરળ છે, એટલું સરળ છે કે તમે વર્ચ્યુઅલ રીતે કોઈ તાલીમ વિના કોડ વાંચી શકો છો. ભાષાની આ સુવિધાનો ઉપયોગ ઘણી વૈશ્વિક કંપનીઓમાં થાય છે, જ્યારે કોડને નોન-કોર નિષ્ણાતો (મેનેજરો, ગ્રાહકો, વગેરે) સાથે મળીને વાંચવામાં આવે છે. ડિઝાઇન આધારિત વિકાસ જેવી પદ્ધતિઓ માટે આ ખૂબ અનુકૂળ છે.
શિખાઉ પ્રોગ્રામરો પણ એક કે બે અઠવાડિયા પછી તદ્દન યોગ્ય કોડ બનાવવાનું શરૂ કરે છે. મેં જે પુસ્તકમાંથી અભ્યાસ કર્યો તે છે “ગો પ્રોગ્રામિંગ” (માર્ક સમરફિલ્ડ દ્વારા). પુસ્તક ખૂબ જ સારું છે, તે ભાષાની ઘણી ઘોંઘાટને સ્પર્શે છે. જાવા, PHP જેવી બિનજરૂરી જટિલ ભાષાઓ પછી, જાદુનો અભાવ તાજગી આપે છે. પરંતુ વહેલા કે પછી, ઘણા મર્યાદિત પ્રોગ્રામરોને નવા ક્ષેત્રમાં જૂની પદ્ધતિઓનો ઉપયોગ કરવાનો વિચાર છે. શું આ ખરેખર જરૂરી છે?

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

તો શા માટે તેને આટલું સરળ બનાવવામાં આવ્યું? અહીં રોબ પાઇકના કેટલાક અવતરણો છે:

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

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

શાણા શબ્દો, તે નથી?

સાદગીની કલાકૃતિઓ

સુંદરતા માટે સરળતા એ જરૂરી શરત છે. લેવ ટોલ્સટોય.

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

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

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

જ્યારે તેની સ્વતંત્રતા અવરોધાય છે ત્યારે કલા સહન કરતી નથી. ચોકસાઈ તેની જવાબદારી નથી.

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

ઉદાહરણ તરીકે, કન્સોલ યુટિલિટી કે જે stdin વાંચે છે અથવા આદેશ વાક્ય દલીલોમાંથી ફાઇલ આના જેવી દેખાશે:

package main

import (
    "bufio"
    "flag"
    "fmt"
    "log"
    "os"
)

func main() {

    flag.Parse()

    scanner := newScanner(flag.Args())

    var text string
    for scanner.Scan() {
        text += scanner.Text()
    }

    if err := scanner.Err(); err != nil {
        log.Fatal(err)
    }

    fmt.Println(text)
}

func newScanner(flags []string) *bufio.Scanner {
    if len(flags) == 0 {
        return bufio.NewScanner(os.Stdin)
    }

    file, err := os.Open(flags[0])

    if err != nil {
        log.Fatal(err)
    }

    return bufio.NewScanner(file)
}

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 main() {

    list32 := []int32{1, 2, 3, 4, 5}
    list64 := []int64{1, 2, 3, 4, 5}

    fmt.Println(int32Sum(list32))
    fmt.Println(int64Sum(list64))
}

આવા બાંધકામોને અમલમાં મૂકવા માટે ભાષા પાસે પૂરતા માધ્યમો છે. ઉદાહરણ તરીકે, સામાન્ય પ્રોગ્રામિંગ સારું રહેશે.

package main

import "fmt"

func Eval32(list []int32, fn func(a, b int32)int32) int32 {
    var res int32
    for _, val := range list {
        res = fn(res, val)
    }
    return res
}

func int32Add(a, b int32) int32 {
    return a + b
}

func int32Sub(a, b int32) int32 {
    return a + b
}

func Eval64(list []int64, fn func(a, b int64)int64) int64 {
    var res int64
    for _, val := range list {
        res = fn(res, val)
    }
    return res
}

func int64Add(a, b int64) int64 {
    return a + b
}

func int64Sub(a, b int64) int64 {
    return a - b
}

func main() {

    list32 := []int32{1, 2, 3, 4, 5}
    list64 := []int64{1, 2, 3, 4, 5}

    fmt.Println(Eval32(list32, int32Add))
    fmt.Println(Eval64(list64, int64Add))
    fmt.Println(Eval64(list64, int64Sub))
}

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

ઘણા કહેશે કે D માં પ્રોગ્રામ નોંધપાત્ર રીતે ટૂંકો લાગે છે, અને તે યોગ્ય હશે.

import std.stdio;
import std.algorithm;

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

જો કે, તે માત્ર ટૂંકું છે, પરંતુ વધુ યોગ્ય નથી, કારણ કે D અમલીકરણ ભૂલ સંભાળવાની સમસ્યાને સંપૂર્ણપણે અવગણે છે.

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

જાળવણીક્ષમતા, એક્સ્ટેન્સિબિલિટી અને વાંચનક્ષમતાના સંદર્ભમાં, મારા મતે, ગો ભાષા જીતે છે, જો કે તે વર્બોસિટીમાં હારી જાય છે.

કેટલાક કિસ્સાઓમાં સામાન્યકૃત પ્રોગ્રામિંગ અમને નિર્વિવાદ લાભ આપે છે. આ સૉર્ટ પેકેજ દ્વારા સ્પષ્ટપણે દર્શાવવામાં આવ્યું છે. તેથી, કોઈપણ સૂચિને સૉર્ટ કરવા માટે, આપણે ફક્ત sort.Interface ઈન્ટરફેસને અમલમાં મૂકવાની જરૂર છે.

import "sort"

type Names []string

func (ns Names) Len() int {
    return len(ns)
}

func (ns Names) Less(i, j int) bool {
    return ns[i] < ns[j]
}

func (ns Names) Swap(i, j int) {
    ns[i], ns[j] = ns[j], ns[i]
}

func main() {
    names := Names{"London", "Berlin", "Rim"}
    sort.Sort(names)
}

જો તમે કોઈપણ ઓપન સોર્સ પ્રોજેક્ટ લો અને grep “interface{}” -R આદેશ ચલાવો, તો તમે જોશો કે કેટલી વાર ગૂંચવણમાં મૂકે તેવા ઈન્ટરફેસનો ઉપયોગ થાય છે. નજીકના સાથીદારો તરત જ કહેશે કે આ બધું જનરિક્સના અભાવને કારણે છે. જો કે, આ હંમેશા કેસ નથી. ચાલો એક ઉદાહરણ તરીકે ડેલ્ફી લઈએ. આ સમાન જિનેરિક્સની હાજરી હોવા છતાં, તેમાં મનસ્વી ડેટા પ્રકારો સાથેની કામગીરી માટે વિશિષ્ટ VARIANT પ્રકાર છે. ગો ભાષા એ જ કરે છે.

તોપથી સ્પેરો સુધી

અને સ્ટ્રેટજેકેટ ગાંડપણના કદને બંધબેસતું હોવું જોઈએ. સ્ટેનિસ્લાવ લેક.

ઘણા આત્યંતિક ચાહકો દાવો કરી શકે છે કે ગો પાસે સામાન્ય બનાવવા માટેની બીજી પદ્ધતિ છે - પ્રતિબિંબ. અને તેઓ સાચા હશે... પરંતુ માત્ર ભાગ્યે જ કિસ્સાઓમાં.

રોબ પાઈક અમને ચેતવણી આપે છે:

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

વિકિપીડિયા અમને નીચેના કહે છે:

પ્રતિબિંબ એ પ્રક્રિયાને સંદર્ભિત કરે છે જે દરમિયાન એક્ઝેક્યુશન દરમિયાન પ્રોગ્રામ તેની પોતાની રચના અને વર્તણૂકનું નિરીક્ષણ કરી શકે છે અને તેમાં ફેરફાર કરી શકે છે. પ્રોગ્રામિંગ પેરાડાઈમ અંતર્ગત પ્રતિબિંબને રિફ્લેક્ટિવ પ્રોગ્રામિંગ કહેવામાં આવે છે. આ મેટાપ્રોગ્રામિંગનો એક પ્રકાર છે.

જો કે, જેમ તમે જાણો છો, તમારે દરેક વસ્તુ માટે ચૂકવણી કરવી પડશે. આ કિસ્સામાં તે છે:

• પ્રોગ્રામ લખવામાં મુશ્કેલી
• પ્રોગ્રામ એક્ઝેક્યુશનની ઝડપ

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

ક્ઝી તરફથી સાંસ્કૃતિક સામાન? ના, સંખ્યાબંધ ભાષાઓમાંથી!

નસીબની સાથે વારસદારો પર દેવા પણ બાકી છે.

ઘણા લોકો માને છે કે ભાષા સંપૂર્ણપણે C વારસા પર આધારિત છે તે હકીકત હોવા છતાં, આ કેસ નથી. ભાષા શ્રેષ્ઠ પ્રોગ્રામિંગ ભાષાઓના ઘણા પાસાઓને સમાવિષ્ટ કરે છે.

વાક્યરચના

સૌ પ્રથમ, વ્યાકરણની રચનાની વાક્યરચના C ભાષાના વાક્યરચના પર આધારિત છે. જો કે, ડેલ્ફી ભાષાનો પણ નોંધપાત્ર પ્રભાવ હતો. આમ, આપણે જોઈએ છીએ કે નિરર્થક કૌંસ, જે પ્રોગ્રામની વાંચનક્ષમતાને મોટા પ્રમાણમાં ઘટાડે છે, સંપૂર્ણપણે દૂર કરવામાં આવ્યા છે. ભાષામાં DELPHI ભાષામાં અંતર્ગત “:=” ઓપરેટર પણ છે. પેકેજનો ખ્યાલ ADA જેવી ભાષાઓમાંથી ઉધાર લેવામાં આવ્યો છે. બિનઉપયોગી એકમોની ઘોષણા PROLOG ભાષામાંથી લેવામાં આવી છે.

અર્થશાસ્ત્ર

પેકેજો ડેલ્ફી ભાષાના અર્થશાસ્ત્ર પર આધારિત હતા. દરેક પેકેજ ડેટા અને કોડને સમાવિષ્ટ કરે છે અને તેમાં ખાનગી અને જાહેર સંસ્થાઓનો સમાવેશ થાય છે. આ તમને પેકેજ ઇન્ટરફેસને ન્યૂનતમ સુધી ઘટાડવા માટે પરવાનગી આપે છે.

ડેલિગેશન પદ્ધતિ દ્વારા અમલીકરણની કામગીરી ડેલ્ફી ભાષામાંથી ઉધાર લેવામાં આવી હતી.

સંકલન

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

ઉચ્ચ સ્તરીય બાંધકામો

ભાષામાં ઘણાં જુદાં જુદાં ઉચ્ચ-સ્તરનાં બાંધકામો છે જે સી જેવી નિમ્ન-સ્તરની ભાષાઓ સાથે કોઈ રીતે સંબંધિત નથી.

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

મેમરી મેનેજમેન્ટ

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

સહવર્તી અને સહવર્તી

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

વધારાના લાભો

જો તે નફાકારક હશે, તો દરેક વ્યક્તિ નિઃસ્વાર્થ બની જશે.

ભાષા આપણને સંખ્યાબંધ અસંદિગ્ધ લાભો પણ પ્રદાન કરે છે:

• પ્રોજેક્ટ બનાવ્યા પછી એક જ એક્ઝિક્યુટેબલ ફાઇલ એપ્લીકેશનની જમાવટને મોટા પ્રમાણમાં સરળ બનાવે છે.
• સ્ટેટિક ટાઇપિંગ અને ટાઇપ ઇન્ફરન્સ તમારા કોડમાં ભૂલોની સંખ્યાને નોંધપાત્ર રીતે ઘટાડી શકે છે, પરીક્ષણો લખ્યા વિના પણ. હું કેટલાક પ્રોગ્રામરોને જાણું છું જેઓ પરીક્ષણો લખ્યા વિના જ કરે છે અને તેમના કોડની ગુણવત્તાને નોંધપાત્ર રીતે નુકસાન થતું નથી.
• ખૂબ જ સરળ ક્રોસ-કમ્પાઇલેશન અને સ્ટાન્ડર્ડ લાઇબ્રેરીની ઉત્તમ પોર્ટેબિલિટી, જે ક્રોસ-પ્લેટફોર્મ એપ્લિકેશન્સના વિકાસને મોટા પ્રમાણમાં સરળ બનાવે છે.
• RE2 રેગ્યુલર એક્સપ્રેશન્સ થ્રેડ-સેફ છે અને તેના અમલીકરણનો અનુમાનિત સમય છે.
• એક શક્તિશાળી પ્રમાણભૂત લાઇબ્રેરી જે મોટાભાગના પ્રોજેક્ટ્સને તૃતીય-પક્ષ ફ્રેમવર્ક વિના કરવાની મંજૂરી આપે છે.
• સમસ્યાને કેવી રીતે હલ કરવી તેના બદલે તેના પર ધ્યાન કેન્દ્રિત કરવા માટે ભાષા એટલી શક્તિશાળી છે, છતાં સમસ્યાને અસરકારક રીતે ઉકેલી શકાય તેટલું નીચું સ્તર છે.
• ગો ઈકો સિસ્ટમ પહેલાથી જ તમામ પ્રસંગો માટે બૉક્સની બહાર વિકસિત ટૂલ્સ ધરાવે છે: પરીક્ષણો, દસ્તાવેજીકરણ, પેકેજ મેનેજમેન્ટ, શક્તિશાળી લિંટર્સ, કોડ જનરેશન, રેસ કન્ડીશન ડિટેક્ટર વગેરે.
• ગો વર્ઝન 1.11 એ બિલ્ટ-ઇન સિમેન્ટીક ડિપેન્ડન્સી મેનેજમેન્ટ રજૂ કર્યું છે, જે લોકપ્રિય VCS હોસ્ટિંગની ટોચ પર બનેલું છે. ગો ઇકોસિસ્ટમ બનાવેલ તમામ સાધનો આ સેવાઓનો ઉપયોગ એક જ વારમાં તેમાંથી કોડ ડાઉનલોડ કરવા, બિલ્ડ કરવા અને ઇન્સ્ટોલ કરવા માટે કરે છે. અને તે મહાન છે. સંસ્કરણ 1.11 ના આગમન સાથે, પેકેજ સંસ્કરણની સમસ્યા પણ સંપૂર્ણપણે ઉકેલાઈ ગઈ.
• કારણ કે ભાષાનો મુખ્ય વિચાર જાદુને ઘટાડવાનો છે, ભાષા વિકાસકર્તાઓને સ્પષ્ટપણે ભૂલને નિયંત્રિત કરવા માટે પ્રોત્સાહિત કરે છે. અને આ સાચું છે, કારણ કે અન્યથા, તે ફક્ત ભૂલને નિયંત્રિત કરવાનું સંપૂર્ણપણે ભૂલી જશે. બીજી બાબત એ છે કે મોટા ભાગના વિકાસકર્તાઓ ઇરાદાપૂર્વક એરર હેન્ડલિંગની અવગણના કરે છે, ભૂલને ઉપરની તરફ આગળ મોકલવાને બદલે તેની પ્રક્રિયા કરવાનું પસંદ કરે છે.
• ભાષા શાસ્ત્રીય OOP પદ્ધતિનો અમલ કરતી નથી, કારણ કે તેના શુદ્ધ સ્વરૂપમાં ગોમાં કોઈ વર્ચ્યુઅલિટી નથી. જો કે, ઇન્ટરફેસનો ઉપયોગ કરતી વખતે આ કોઈ સમસ્યા નથી. OOP ની ગેરહાજરી નવા નિશાળીયા માટે પ્રવેશ માટેના અવરોધને નોંધપાત્ર રીતે ઘટાડે છે.

સમુદાયના લાભ માટે સરળતા

તેને જટિલ બનાવવું સરળ છે, સરળ બનાવવું મુશ્કેલ છે.

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

કંપનીઓને સંખ્યાબંધ ફાયદાઓ પણ મળે છે: ઓછી પ્રવેશ અવરોધ તેમને ઝડપથી નિષ્ણાત શોધવાની મંજૂરી આપે છે, અને ભાષાની અપરિવર્તનક્ષમતા તેમને 10 વર્ષ પછી પણ સમાન કોડનો ઉપયોગ કરવાની મંજૂરી આપે છે.

નિષ્કર્ષ

મોટા મગજના કદે ક્યારેય કોઈ હાથીને નોબેલ પ્રાઈઝ વિજેતા બનાવ્યો નથી.

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

સોર્સ: www.habr.com