L-artiklu nkiteb bħala tweġiba għal dokument ippubblikat qabel artikolu antipodean.

Matul l-aħħar sentejn u aktar ilni nuża Go biex nimplimenta server RADIUS speċjalizzat b'sistema ta' kontijiet żviluppata. Tul it-triq, qed nitgħallem l-intricacies tal-lingwa nnifisha. Il-programmi nfushom huma sempliċi ħafna u mhumiex l-iskop ta 'dan l-artikolu, iżda l-esperjenza tal-użu ta' Go stess jistħoqqilha ftit kliem fid-difiża tagħha. Go qed isir lingwaġġ dejjem aktar mainstream għal kodiċi serju u skalabbli. Il-lingwa ġiet maħluqa minn Google, fejn tintuża b'mod attiv. Bottom line, onestament naħseb li d-disinn tal-lingwa Go huwa ħażin għal programmaturi UNintelligent.

Iddisinjat għal programmaturi dgħajfa?

Id-dgħajjef jitkellmu dwar problemi. It-taħdita qawwija dwar ideat u ħolm...

Go huwa faċli ħafna biex titgħallem, tant faċli li tista 'taqra l-kodiċi prattikament mingħajr taħriġ. Din il-karatteristika tal-lingwa tintuża f'ħafna kumpaniji globali, meta l-kodiċi jinqara flimkien ma 'speċjalisti mhux ewlenin (maniġers, klijenti, eċċ.). Dan huwa konvenjenti ħafna għal metodoloġiji bħal Design Driven Development.
Anke programmaturi novizzi jibdew jipproduċu kodiċi pjuttost deċenti wara ġimgħa jew tnejn. Il-ktieb li studjajt minnu huwa “Go Programming” (minn Mark Summerfield). Il-ktieb huwa tajjeb ħafna, imiss ħafna sfumaturi tal-lingwa. Wara lingwi kkumplikati bla bżonn bħal Java, PHP, in-nuqqas ta 'maġija huwa iġjeniċi. Imma llum jew għada, ħafna programmaturi limitati għandhom l-idea li jużaw metodi qodma f'qasam ġdid. Dan huwa verament meħtieġ?

Rob Pike (l-ideologu ewlieni tal-lingwa) ħoloq il-lingwa Go bħala lingwa industrijali li hija faċli biex tinftiehem u effettiva biex tintuża. Il-lingwa hija mfassla għall-produttività massima f'timijiet kbar u m'hemm l-ebda dubju dwarha. Ħafna programmaturi novizzi jilmentaw li hemm ħafna karatteristiċi li huma neqsin. Din ix-xewqa għas-sempliċità kienet deċiżjoni konxja mid-disinjaturi tal-lingwa, u sabiex nifhmu bis-sħiħ għaliex kienet meħtieġa, irridu nifhmu l-motivazzjoni tal-iżviluppaturi u dak li kienu qed jippruvaw jiksbu f'Go.

Allura għaliex saret daqshekk sempliċi? Hawn huma ftit kwotazzjonijiet minn Rob Pike:

Il-punt ewlieni hawnhekk huwa li l-programmaturi tagħna mhumiex riċerkaturi. Huma, bħala regola, pjuttost żgħar, jiġu għandna wara li studjaw, forsi studjaw Java, jew C/C++, jew Python. Ma jistgħux jifhmu lingwa kbira, iżda fl-istess ħin irridu li joħolqu softwer tajjeb. Huwa għalhekk li l-lingwa għandha tkun faċli biex tinftiehem u titgħallem.

Huwa għandu jkun familjari, bejn wieħed u ieħor simili għal C. Il-programmaturi li jaħdmu ma' Google jibdew il-karriera tagħhom kmieni u huma l-aktar familjari mal-lingwi proċedurali, b'mod partikolari l-familja C. Ir-rekwiżit għal produttività ta' malajr f'lingwa ta' programmar ġdida tfisser li l-lingwa m'għandhiex tkun radikali wisq.

Kliem għaqli, hux?

Artifacts ta 'Sempliċità

Is-sempliċità hija kundizzjoni meħtieġa għas-sbuħija. Lev Tolstoy.

Li żżommha sempliċi hija waħda mill-aktar għanijiet importanti fi kwalunkwe disinn. Kif tafu, proġett perfett mhuwiex proġett fejn m'hemm xejn x'iżżid, iżda wieħed li minnu m'hemm xejn x'tneħħi. Ħafna nies jemmnu li sabiex issolvi (jew saħansitra jesprimu) problemi kumplessi, hija meħtieġa għodda kumplessa. Madankollu, mhuwiex. Ejja nieħdu l-lingwa PERL per eżempju. L-ideoloġisti tal-lingwa jemmnu li programmatur għandu jkollu mill-inqas tliet modi differenti biex isolvi problema waħda. L-ideologi tal-lingwa Go ħadu triq differenti huma ddeċidew li mod wieħed, iżda wieħed tassew tajjeb, kien biżżejjed biex jintlaħaq l-għan; Dan l-approċċ għandu bażi serja: l-uniku mod huwa aktar faċli biex titgħallem u aktar diffiċli biex tinsa.

Ħafna migranti jilmentaw li l-lingwa ma fihax estrazzjonijiet eleganti. Iva, dan huwa minnu, iżda dan huwa wieħed mill-vantaġġi ewlenin tal-lingwa. Il-lingwa fiha minimu ta 'maġija - għalhekk l-ebda għarfien profond huwa meħtieġ biex taqra l-programm. Fir-rigward tal-verbożità tal-kodiċi, din mhi problema xejn. Programm Golang miktub tajjeb jaqra vertikalment, bi ftit jew xejn struttura. Barra minn hekk, il-veloċità tal-qari ta 'programm hija mill-inqas ordni ta' kobor akbar mill-veloċità tal-kitba tiegħu. Jekk tqis li l-kodiċi kollu għandu ifformattjar uniformi (magħmul bl-użu tal-kmand gofmt inkorporat), allura l-qari ta 'ftit linji żejda mhu problema xejn.

Mhux espressiv ħafna

L-arti ma tittollerax meta l-libertà tagħha tkun ristretta. L-eżattezza mhix ir-responsabbiltà tiegħu.

Minħabba x-xewqa għas-sempliċità, Go m'għandux kostruzzjonijiet li f'lingwi oħra huma pperċepiti bħala xi ħaġa naturali minn nies imdorrijin bihom. Għall-ewwel jista 'jkun kemmxejn inkonvenjenti, iżda mbagħad tinnota li l-programm huwa ħafna aktar faċli u mhux ambigwu biex jinqara.

Pereżempju, utilità tal-console li taqra stdin jew fajl mill-argumenti tal-linja tal-kmand tkun tidher bħal din:

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

Is-soluzzjoni għall-istess problema f'D, għalkemm tidher kemmxejn iqsar, mhix aktar faċli biex tinqara

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

Infern tal-ikkupjar

Il-bniedem iġorr l-infern fih innifsu. Martin Luther.

Dawk li jibdew kontinwament jilmentaw dwar Go f'termini ta 'nuqqas ta' ġeneriċi. Biex issolvi din il-kwistjoni, ħafna minnhom jużaw l-ikkupjar dirett tal-kodiċi. Pereżempju, funzjoni biex tinġabar lista ta 'numri interi, professjonisti bħal dawn jemmnu li l-funzjonalità ma tistax tiġi implimentata b'xi mod ieħor ħlief b'sempliċi kopja-pejst għal kull tip ta' dejta.

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

Il-lingwa għandha mezzi biżżejjed biex timplimenta kostruzzjonijiet bħal dawn. Pereżempju, l-ipprogrammar ġeneriku jkun tajjeb.

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

U, għalkemm il-kodiċi tagħna rriżulta li kien kemmxejn itwal mill-każ preċedenti, sar ġeneralizzat. Għalhekk, mhux se jkun diffiċli għalina li nimplimentaw l-operazzjonijiet aritmetiċi kollha.

Ħafna jgħidu li programm f'D jidher iqsar b'mod sinifikanti, u se jkollhom raġun.

import std.stdio;
import std.algorithm;

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

Madankollu, huwa biss iqsar, iżda mhux aktar korrett, peress li l-implimentazzjoni D tinjora kompletament il-problema tal-immaniġġjar tal-iżbalji.

Fil-ħajja reali, hekk kif tiżdied il-kumplessità tal-loġika, id-distakk jonqos malajr. Id-distakk jingħalaq saħansitra aktar malajr meta jkollok bżonn twettaq azzjoni li ma tistax titwettaq bl-użu ta' operaturi tal-lingwa standard.

F'termini ta 'manutenzjoni, estensibilità, u leġibbiltà, fl-opinjoni tiegħi, il-lingwa Go tirbaħ, għalkemm titlef fil-verosità.

Programmazzjoni ġeneralizzata f'xi każijiet tagħtina benefiċċji innegabbli. Dan huwa muri b'mod ċar mill-pakkett tas-sort. Allura, biex issolvi kwalunkwe lista, għandna bżonn biss li nimplimentaw l-interface 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)
}

Jekk tieħu xi proġett ta 'sors miftuħ u tħaddem il-kmand grep "interface{}" -R, tara kemm-il darba jintużaw interfaces konfużi. Sħabi moħħom mill-qrib se jgħidu immedjatament li dan kollu huwa minħabba n-nuqqas ta 'ġeneriċi. Madankollu, dan mhux dejjem il-każ. Ejja nieħdu lil DELPHI bħala eżempju. Minkejja l-preżenza ta 'dawn l-istess ġeneriċi, fih tip ta' VARIANT speċjali għal operazzjonijiet b'tipi ta 'dejta arbitrarji. Il-lingwa Go tagħmel l-istess.

Minn kanun għal għasafar

U l-ġakketta tal-forza trid taqbel mad-daqs tal-ġenn. Stanislav Lec.

Ħafna fans estremi jistgħu jsostnu li Go għandha mekkaniżmu ieħor għall-ħolqien ta 'ġeneriċi - riflessjoni. U se jkollhom raġun... imma f'każijiet rari biss.

Rob Pike iwissina:

Din hija għodda qawwija li għandha tintuża b'kawtela. Għandu jiġi evitat sakemm ma jkunx strettament meħtieġ.

Il-Wikipedija tgħidilna dan li ġej:

Ir-riflessjoni tirreferi għall-proċess li matulu programm jista' jimmonitorja u jimmodifika l-istruttura u l-imġieba tiegħu stess waqt l-eżekuzzjoni. Il-paradigma tal-ipprogrammar sottostanti r-riflessjoni tissejjaħ programmar riflessiv. Dan huwa tip ta 'metaprogramming.

Madankollu, kif tafu, trid tħallas għal kollox. F'dan il-każ huwa:

diffikultà biex tikteb programmi
veloċità ta 'eżekuzzjoni tal-programm

Għalhekk, ir-riflessjoni għandha tintuża b'kawtela, bħal arma ta 'kalibru kbir. Użu bla ħsieb tar-riflessjoni jwassal għal programmi li ma jinqrawx, żbalji kostanti u veloċità baxxa. Biss il-ħaġa għal programmatur snob biex ikun jista’ juri l-kodiċi tiegħu quddiem kollegi oħra, aktar pragmatiċi u modesti.

Bagalji kulturali minn Xi? Le, minn numru ta’ lingwi!

Flimkien mal-fortuna, id-djun jitħallew ukoll għall-werrieta.

Minkejja l-fatt li ħafna jemmnu li l-lingwa hija bbażata għal kollox fuq il-wirt Ċ, dan mhux il-każ. Il-lingwa tinkorpora ħafna aspetti ta 'l-aqwa lingwi ta' programmar.

sintassi

L-ewwelnett, is-sintassi tal-istrutturi grammatikali hija bbażata fuq is-sintassi tal-lingwa Ċ. Madankollu, il-lingwa DELPHI kellha wkoll influwenza sinifikanti. Għalhekk, naraw li l-parentesi żejda, li jnaqqsu ħafna l-leġibbiltà tal-programm, tneħħew kompletament. Il-lingwa fiha wkoll l-operatur “:=" inerenti għal-lingwa DELPHI. Il-kunċett ta 'pakketti huwa misluf minn lingwi bħall-ADA. Id-dikjarazzjoni ta' entitajiet mhux użati hija mislufa mil-lingwa PROLOG.

Semantika

Il-pakketti kienu bbażati fuq is-semantika tal-lingwa DELPHI. Kull pakkett jiġbor fih dejta u kodiċi u fih entitajiet privati u pubbliċi. Dan jippermettilek tnaqqas l-interface tal-pakkett għall-minimu.

L-operazzjoni ta' implimentazzjoni b'metodu ta' delega ġiet mislufa mil-lingwa DELPHI.

Kumpilazzjoni

Mhux bla raġuni li hemm ċajta: Go ġie żviluppat waqt li kien qed jiġi kkompilat programm C. Waħda mis-saħħiet tal-lingwa hija l-kumpilazzjoni ultra-veloċi tagħha. L-idea ġiet mislufa mil-lingwa DELPHI. Kull pakkett Go jikkorrispondi għal modulu DELPHI. Dawn il-pakketti jiġu kkompilati mill-ġdid biss meta verament meħtieġ. Għalhekk, wara l-editjar li jmiss, m'għandekx bżonn tikkompila l-programm kollu, iżda pjuttost tikkompila mill-ġdid biss il-pakketti mibdula u l-pakketti li jiddependu fuq dawn il-pakketti mibdula (u anke allura, biss jekk l-interfaces tal-pakkett ikunu nbidlu).

Kostruzzjonijiet ta' livell għoli

Il-lingwa fiha ħafna kostruzzjonijiet differenti ta 'livell għoli li bl-ebda mod ma huma relatati ma' lingwi ta 'livell baxx bħal C.

Kordi
Tabelli tal-hash
Flieli
It-tajpjar tal-papri huwa misluf minn lingwi bħal RUBY (li, sfortunatament, ħafna ma jifhmux jew ma jużawx il-potenzjal sħiħ tiegħu).

Ġestjoni tal-memorja

Ġestjoni tal-memorja ġeneralment jistħoqqilha artiklu separat. Jekk f'lingwi bħal C++, il-kontroll jitħalla kompletament f'idejn l-iżviluppatur, allura f'lingwi aktar tard bħal DELPHI, intuża mudell ta 'għadd ta' referenza. B'dan l-approċċ, referenzi ċikliċi ma kinux permessi, peress li ġew iffurmati raggruppamenti orfni, allura Go għandha skoperta integrata ta 'raggruppamenti bħal dawn (bħal C#). Barra minn hekk, il-kollettur taż-żibel huwa aktar effiċjenti mill-biċċa l-kbira tal-implimentazzjonijiet magħrufa bħalissa u diġà jista 'jintuża għal ħafna kompiti f'ħin reali. Il-lingwa nnifisha tirrikonoxxi sitwazzjonijiet meta valur biex taħżen varjabbli jista 'jiġi allokat fuq il-munzell. Dan inaqqas it-tagħbija fuq il-maniġer tal-memorja u jżid il-veloċità tal-programm.

Konkorrenza u Konferenza

Il-paralleliżmu u l-kompetittività tal-lingwa hija lil hinn mit-tifħir. L-ebda lingwa ta’ livell baxx ma tista’ tikkompeti anki mill-bogħod ma’ Go. Biex inkun ġust, ta 'min jinnota li l-mudell ma kienx ivvintat mill-awturi tal-lingwa, iżda kien sempliċement misluf mil-lingwa tajba ADA antik. Il-lingwa hija kapaċi tipproċessa miljuni ta 'konnessjonijiet paralleli bl-użu tas-CPUs kollha, filwaqt li għandha ordni ta' kobor problemi inqas kumplessi b'deadlocks u kundizzjonijiet ta 'razza li huma tipiċi għal kodiċi multi-threaded.

Benefiċċji addizzjonali

Jekk ikun profittabbli, kulħadd se jsir selfless.

Il-lingwa tagħtina wkoll numru ta’ benefiċċji bla dubju:

Fajl eżekutibbli wieħed wara li jinbena l-proġett jissimplifika ħafna l-iskjerament tal-applikazzjonijiet.
It-tajpjar statiku u l-inferenza tat-tip jistgħu jnaqqsu b'mod sinifikanti n-numru ta 'żbalji fil-kodiċi tiegħek, anke mingħajr testijiet tal-kitba. Naf xi programmaturi li jagħmlu mingħajr ma jiktbu testijiet u l-kwalità tal-kodiċi tagħhom ma tbatix b'mod sinifikanti.
Kompilazzjoni inkroċjata sempliċi ħafna u portabbiltà eċċellenti tal-librerija standard, li tissimplifika ħafna l-iżvilupp ta 'applikazzjonijiet ta' pjattaformi differenti.
L-espressjonijiet regolari RE2 huma bla periklu u għandhom ħinijiet ta' eżekuzzjoni prevedibbli.
Librerija standard qawwija li tippermetti li l-biċċa l-kbira tal-proġetti jgħaddu mingħajr oqfsa ta’ partijiet terzi.
Il-lingwa hija b'saħħitha biżżejjed biex tiffoka fuq il-problema aktar milli kif issolviha, iżda ta' livell baxx biżżejjed li l-problema tista 'tiġi solvuta b'mod effiċjenti.
Is-sistema Go eko diġà fiha għodod żviluppati barra mill-kaxxa għall-okkażjonijiet kollha: testijiet, dokumentazzjoni, ġestjoni tal-pakketti, linters b'saħħithom, ġenerazzjoni ta 'kodiċi, rilevatur tal-kundizzjonijiet tat-tellieqa, eċċ.
Il-verżjoni Go 1.11 introduċiet ġestjoni integrata tad-dipendenza semantika, mibnija fuq hosting VCS popolari. L-għodod kollha li jiffurmaw l-ekosistema Go jużaw dawn is-servizzi biex iniżżlu, jibnu, u jinstallaw kodiċi minnhom f'daqqa waħda. U dan huwa kbir. Bil-wasla tal-verżjoni 1.11, il-problema bil-verżjoni tal-pakkett ġiet ukoll solvuta kompletament.
Minħabba li l-idea ewlenija tal-lingwa hija li titnaqqas il-maġija, il-lingwa tinċentiva lill-iżviluppaturi biex jimmaniġġjaw l-iżbalji b'mod espliċitu. U dan huwa korrett, għax inkella, sempliċement tinsa l-immaniġġjar tal-iżbalji għal kollox. Ħaġa oħra hija li l-biċċa l-kbira tal-iżviluppaturi deliberatament jinjoraw l-immaniġġjar tal-iżbalji, u jippreferu minflok jipproċessawhom biex sempliċement jgħaddu l-iżball 'il fuq.
Il-lingwa ma timplimentax il-metodoloġija klassika OOP, peress li fil-forma pura tagħha m'hemm l-ebda virtalità f'Go. Madankollu, din mhix problema meta tuża interfaces. In-nuqqas ta 'OOP inaqqas b'mod sinifikanti l-ostaklu għad-dħul għal dawk li jibdew.

Sempliċità għall-benefiċċju tal-komunità

Huwa faċli li tikkomplika, diffiċli li tissimplifika.

Go kienet iddisinjata biex tkun sempliċi u tirnexxi f'dak l-għan. Inkiteb għal programmaturi intelliġenti li jifhmu l-benefiċċji tax-xogħol f'tim u huma għajjien mill-varjabbiltà bla tarf tal-lingwi fil-livell tal-Intrapriża. Li għandu sett relattivament żgħir ta 'strutturi sintattiċi fl-armament tiegħu, huwa prattikament mhux soġġett għal bidliet maż-żmien, għalhekk l-iżviluppaturi għandhom ħafna ħin meħlus għall-iżvilupp, u mhux biex jistudjaw bla tmiem l-innovazzjonijiet tal-lingwa.

Kumpaniji jirċievu wkoll għadd ta 'vantaġġi: ostaklu baxx tad-dħul jippermettilhom li jsibu speċjalista malajr, u l-immutabilità tal-lingwa tippermettilhom jużaw l-istess kodiċi anke wara 10 snin.

Konklużjoni

Daqs kbir tal-moħħ qatt ma għamel l-ebda iljunfant rebbieħ tal-Premju Nobel.

Għal dawk il-programmaturi li l-ego personali tagħhom jieħu preċedenza fuq l-ispirtu tat-tim, kif ukoll it-teoristi li jħobbu l-isfidi akkademiċi u l-"awto-titjib" bla tarf, il-lingwa hija tassew ħażina, peress li hija lingwaġġ artiġjanali għal skopijiet ġenerali li ma jippermettilekx tikseb pjaċir estetiku mir-riżultat tax-xogħol tiegħek u uri lilek innifsek professjonali quddiem il-kollegi (sakemm inkejlu l-intelliġenza b'dawn il-kriterji, u mhux bl-IQ). Bħal kull ħaġa fil-ħajja, hija kwistjoni ta’ prijoritajiet personali. Bħal kull innovazzjonijiet utli, il-lingwa diġà mxiet triq twila minn ċaħda universali għal aċċettazzjoni tal-massa. Il-lingwa hija inġenjuża fis-sempliċità tagħha, u, kif tafu, kollox inġenjuż huwa sempliċi!

Sors: www.habr.com

Għaliex Go hija Ħażina għal Programmaturi Unsmart