Gisulat ang artikulo isip tubag sa usa nga gipatik kaniadto antipodean nga artikulo.

Sulod sa milabay nga duha ka dugang nga mga tuig akong gigamit ang Go aron ipatuman ang usa ka espesyal nga RADIUS server nga adunay usa ka naugmad nga sistema sa pagsingil. Sa kadugayan, nagkat-on ko sa mga kakuti sa pinulongan mismo. Ang mga programa mismo yano ra kaayo ug dili ang katuyoan sa kini nga artikulo, apan ang kasinatian sa paggamit sa Go mismo angayan sa pipila ka mga pulong sa pagdepensa niini. Ang Go nahimong mas mainstream nga pinulongan alang sa seryoso, scalable code. Ang pinulongan gimugna sa Google, diin kini aktibo nga gigamit. Ubos nga linya, matinud-anon kong naghunahuna nga ang disenyo sa Go nga pinulongan dili maayo alang sa UNintelligent programmers.

Gidisenyo alang sa huyang nga mga programmer?

Ang mga mahuyang nagsulti sa mga problema. Ang kusog nga paghisgot bahin sa mga ideya ug mga damgo...

Ang Go sayon kaayo nga makat-on, sayon kaayo nga imong mabasa ang code nga halos walay pagbansay. Kini nga bahin sa lengguwahe gigamit sa daghang mga global nga kompanya kung ang code gibasa kauban ang mga non-core nga mga espesyalista (manager, kustomer, ug uban pa). Kini sayon kaayo alang sa mga pamaagi sama sa Design Driven Development.
Bisan ang mga bag-ong programmer nagsugod sa paghimo og medyo desente nga code pagkahuman sa usa o duha ka semana. Ang libro nga akong gitun-an mao ang "Go Programming" (ni Mark Summerfield). Ang libro maayo kaayo, kini nakatandog sa daghang mga nuances sa pinulongan. Pagkahuman sa dili kinahanglan nga komplikado nga mga pinulongan sama sa Java, PHP, ang kakulang sa salamangka makapalagsik. Apan sa madugay o sa madali, daghang limitado nga mga programmer ang adunay ideya sa paggamit sa daan nga mga pamaagi sa usa ka bag-ong natad. Kinahanglan ba gyud kini?

Si Rob Pike (ang nag-unang ideologist sa pinulongan) nagmugna sa Go nga pinulongan isip industriyal nga pinulongan nga sayon sabton ug epektibong gamiton. Ang lengguwahe gidisenyo alang sa labing taas nga produktibidad sa dagkong mga team ug walay pagduhaduha mahitungod niini. Daghang mga bag-ong programmer ang nagreklamo nga adunay daghang mga bahin nga nawala. Kini nga tinguha alang sa kayano usa ka mahunahunaon nga desisyon sa mga tigdesinyo sa pinulongan, ug aron hingpit nga masabtan kung nganong gikinahanglan kini, kinahanglan natong masabtan ang kadasig sa mga developers ug unsa ang ilang gipaningkamutan nga makab-ot sa Go.

Busa nganong kini gihimo nga yano kaayo? Ania ang pipila ka mga kinutlo gikan sa Rob Pike:

Ang yawe nga punto dinhi mao nga ang among mga programmer dili mga tigdukiduki. Sila, ingon nga usa ka lagda, medyo bata pa, mianhi kanamo pagkahuman sa pagtuon, tingali nagtuon sila sa Java, o C/C++, o Python. Dili sila makasabut sa usa ka maayo nga pinulongan, apan sa samang higayon gusto namo nga sila makahimo og maayo nga software. Mao nga ang pinulongan kinahanglan nga sayon sabton ug makat-on.

Kinahanglan nga pamilyar siya, halos parehas sa pagsulti sa C. Ang mga programmer nga nagtrabaho sa Google sayo nga nagsugod sa ilang mga karera ug kasagaran pamilyar sa mga procedural nga mga pinulongan, ilabi na sa pamilyang C. Ang kinahanglanon alang sa dali nga pagka-produktibo sa usa ka bag-ong programming language nagpasabut nga ang pinulongan kinahanglan dili kaayo radikal.

Maalamon nga mga pulong, dili ba?

Mga Artifact sa Kayano

Ang kayano usa ka kinahanglanon nga kondisyon alang sa katahum. Lev Tolstoy.

Ang pagtipig niini nga yano usa sa labing hinungdanon nga mga katuyoan sa bisan unsang disenyo. Sama sa imong nahibal-an, ang usa ka perpekto nga proyekto dili usa ka proyekto diin wala’y idugang, apan usa nga wala’y makuha. Daghang mga tawo ang nagtuo nga aron masulbad (o bisan ipahayag) ang mga komplikado nga mga problema, gikinahanglan ang usa ka komplikado nga himan. Apan, dili. Atong kuhaon pananglitan ang PERL nga pinulongan. Ang mga ideologo sa pinulongan nagtuo nga ang usa ka programmer kinahanglang adunay labing menos tulo ka lain-laing mga paagi sa pagsulbad sa usa ka problema. Ang mga ideologo sa pinulongang Go mikuha ug lahi nga dalan; sila nakahukom nga ang usa ka paagi, apan ang usa ka maayo kaayo, igo na aron makab-ot ang tumong. Kini nga pamaagi adunay usa ka seryoso nga pundasyon: ang bugtong paagi mao ang mas sayon sa pagkat-on ug mas lisud nga kalimtan.

Daghang mga migrante ang nagreklamo nga ang pinulongan wala maglangkob sa mga eleganteng abstraction. Oo, kini tinuod, apan kini mao ang usa sa mga nag-unang bentaha sa pinulongan. Ang pinulongan naglangkob sa usa ka minimum nga salamangka - mao nga walay lawom nga kahibalo nga gikinahanglan sa pagbasa sa programa. Sama sa alang sa verbosity sa code, kini dili usa ka problema sa tanan. Ang usa ka maayong pagkasulat nga programa sa Golang nagbasa nga patindog, nga adunay gamay o wala’y istruktura. Dugang pa, ang katulin sa pagbasa sa usa ka programa labing menos usa ka han-ay sa kadako nga labi pa sa katulin sa pagsulat niini. Kung imong gikonsiderar nga ang tanan nga code adunay parehas nga pag-format (gibuhat gamit ang built-in nga gofmt nga mando), nan ang pagbasa sa pipila ka dugang nga mga linya dili usa ka problema.

Dili kaayo expressive

Ang Art dili motugot kung ang kagawasan niini gipugngan. Ang katukma dili iyang responsibilidad.

Tungod sa tinguha alang sa kayano, ang Go kulang sa mga konstruksyon nga sa ubang mga pinulongan giisip nga natural sa mga tawo nga naanad niini. Sa sinugdan kini mahimong dili kombenyente, apan pagkahuman namatikdan nimo nga ang programa labi ka dali ug labi ka klaro nga basahon.

Pananglitan, ang usa ka console utility nga nagbasa sa stdin o usa ka file gikan sa mga argumento sa command line mahimong ingon niini:

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

Ang solusyon sa parehas nga problema sa D, bisan kung kini labi ka mubo, dili dali basahon

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

Impyerno sa pagkopya

Ang tawo nagdala sa impyerno sulod sa iyang kaugalingon. Martin Luther.

Ang mga nagsugod kanunay nga nagreklamo bahin sa Go bahin sa kakulang sa mga generic. Aron masulbad kini nga isyu, kadaghanan kanila naggamit sa direktang pagkopya sa code. Pananglitan, usa ka function alang sa pagsumada sa usa ka lista sa mga integer, ang ingon nga mga propesyonal nagtuo nga ang pagpaandar dili mapatuman sa bisan unsang paagi kaysa sa yano nga pagkopya-paste alang sa matag tipo sa datos.

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

Ang pinulongan adunay igong paagi sa pagpatuman sa maong mga pagtukod. Pananglitan, maayo ang generic nga programming.

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

Ug, bisan kung ang among code nahimo nga medyo mas taas kaysa sa miaging kaso, nahimo kini nga kinatibuk-an. Busa, dili lisud alang kanato ang pagpatuman sa tanan nga mga operasyon sa aritmetika.

Daghan ang moingon nga ang usa ka programa sa D tan-awon nga mas mubo, ug kini husto.

import std.stdio;
import std.algorithm;

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

Bisan pa, kini mas mubo, apan dili mas husto, tungod kay ang pagpatuman sa D hingpit nga wala magtagad sa problema sa pagdumala sa sayup.

Sa tinuud nga kinabuhi, samtang ang pagkakomplikado sa lohika nagdugang, ang gintang paspas nga naggamay. Ang kal-ang mosirado nga mas paspas kung kinahanglan nimo nga buhaton ang usa ka aksyon nga dili mahimo gamit ang standard nga mga operator sa pinulongan.

Sa termino sa maintainability, extensibility, ug readability, sa akong opinyon, ang Go nga pinulongan modaog, bisan kini mapildi sa verbosity.

Ang kinatibuk-ang programming sa pipila ka mga kaso naghatag kanamo dili ikalimod nga mga benepisyo. Kini tin-aw nga gihulagway sa sort package. Busa, sa paghan-ay sa bisan unsa nga listahan, kita kinahanglan lang sa pagpatuman sa sort.Interface 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)
}

Kung magkuha ka ug bisan unsang open source nga proyekto ug ipadagan ang grep “interface{}” -R nga sugo, imong makita kung unsa ka sagad makalibog nga mga interface ang gigamit. Ang mga suod nga kauban moingon dayon nga kining tanan tungod sa kakuwang sa generics. Bisan pa, dili kini kanunay nga mahitabo. Atong tagdon ang DELPHI isip pananglitan. Bisan pa sa presensya sa parehas nga mga generic, kini adunay usa ka espesyal nga tipo sa VARIANT alang sa mga operasyon nga adunay arbitraryong mga tipo sa datos. Ang Go nga pinulongan nagbuhat sa sama.

Gikan sa kanyon hangtod sa mga goryon

Ug ang straitjacket kinahanglan nga mohaum sa gidak-on sa kabuang. Stanislav Lec.

Daghang mga extreme fans ang mahimong moingon nga si Go adunay laing mekanismo sa paghimo og generics - reflection. Ug sila mahimong husto ... apan sa talagsaon nga mga kaso.

Gipasidan-an kami ni Rob Pike:

Kini usa ka gamhanan nga himan nga kinahanglan gamiton uban ang pag-amping. Kinahanglang likayan kini gawas kon gikinahanglan gayod.

Ang Wikipedia nagsulti kanato sa mosunod:

Ang pagpamalandong nagtumong sa proseso diin ang usa ka programa makamonitor ug makausab sa kaugalingon nga istruktura ug pamatasan sa panahon sa pagpatuman. Ang programming paradigm nga nagpahipi sa pagpamalandong gitawag nga reflective programming. Kini usa ka matang sa metaprogramming.

Bisan pa, ingon sa nahibal-an nimo, kinahanglan nimo nga bayran ang tanan. Sa kini nga kaso kini mao ang:

kalisud sa pagsulat sa mga programa
katulin sa pagpatuman sa programa

Busa, ang pagpamalandong kinahanglang gamiton uban ang pag-amping, sama sa usa ka dako nga kalibre nga hinagiban. Ang walay paghunahuna nga paggamit sa pagpamalandong mosangpot sa dili mabasa nga mga programa, kanunay nga mga sayop ug ubos nga tulin. Ang butang alang sa usa ka snob programmer nga makahimo sa pagpakita sa iyang code sa atubangan sa uban, mas pragmatic ug kasarangan nga mga kauban.

Kultura nga bagahe gikan sa Xi? Dili, gikan sa daghang pinulongan!

Uban sa katigayunan, ang mga utang gibilin usab sa mga manununod.

Bisan pa sa kamatuoran nga daghan ang nagtuo nga ang pinulongan bug-os nga gibase sa C kabilin, dili kini mao ang kaso. Ang pinulongan naglakip sa daghang mga aspeto sa labing maayo nga mga programming language.

syntax

Una sa tanan, ang syntax sa mga istruktura sa gramatika gibase sa syntax sa C nga pinulongan. Bisan pa, ang pinulongang DELPHI adunay dakong impluwensya usab. Sa ingon, among nakita nga ang sobra nga mga parentheses, nga makapakunhod pag-ayo sa pagkabasa sa programa, hingpit nga gikuha. Ang pinulongan naglangkob usab sa ":=" operator nga kinaiyanhon sa DELPHI nga pinulongan. Ang konsepto sa mga pakete gihulam gikan sa mga pinulongan sama sa ADA. Ang deklarasyon sa wala magamit nga mga entidad gihulam gikan sa PROLOG nga pinulongan.

Semantika

Ang mga pakete gibase sa semantiko sa DELPHI nga pinulongan. Ang matag pakete naglangkob sa datos ug code ug naglangkob sa pribado ug publiko nga mga entidad. Kini nagtugot kanimo sa pagpakunhod sa interface sa package ngadto sa usa ka minimum.

Ang operasyon sa pagpatuman pinaagi sa pamaagi sa delegasyon gihulam gikan sa pinulongang DELPHI.

Panagsama

Dili sa walay rason nga adunay usa ka komedya: Ang Go naugmad samtang ang usa ka C nga programa gihugpong. Usa sa mga kalig-on sa pinulongan mao ang ultra-paspas nga paghugpong. Ang ideya gihulam gikan sa pinulongang DELPHI. Ang matag Go package katumbas sa DELPHI module. Kini nga mga pakete gi-recompile lamang kung gikinahanglan. Busa, pagkahuman sa sunod nga pag-edit, dili nimo kinahanglan nga i-compile ang tibuuk nga programa, apan i-recompile lang pag-usab ang nabag-o nga mga pakete ug mga pakete nga nagsalig sa mga nabag-o nga mga pakete (ug bisan pa, kung nabag-o ang mga interface sa package).

Taas nga lebel nga mga konstruksyon

Ang pinulongan naglangkob sa daghang lain-laing mga high-level nga mga konstruksyon nga wala'y kalabutan sa ubos nga lebel nga mga pinulongan sama sa C.

Mga kuwerdas
Hash nga mga lamesa
Mga hiwa
Ang pag-type sa itik gihulam gikan sa mga pinulongan sama sa RUBY (nga, sa kasubo, daghan ang wala makasabut o naggamit sa hingpit nga potensyal niini).

Pagdumala sa memorya

Ang pagdumala sa memorya sa kasagaran angayan sa usa ka lahi nga artikulo. Kung sa mga pinulongan sama sa C ++, ang kontrol hingpit nga ibilin sa developer, unya sa ulahi nga mga pinulongan sama sa DELPHI, usa ka reference counting model ang gigamit. Uban niini nga pamaagi, ang cyclic nga mga pakisayran wala gitugotan, tungod kay ang mga orphan clusters naporma, unya ang Go adunay built-in nga detection sa maong mga clusters (sama sa C#). Dugang pa, ang tigkolekta sa basura mas episyente kaysa sa kadaghanan nga nahibal-an nga mga pagpatuman ug magamit na alang sa daghang mga buluhaton sa tinuud nga oras. Ang pinulongan mismo nag-ila sa mga sitwasyon kung ang usa ka bili sa pagtipig sa usa ka variable mahimong igahin sa stack. Kini makapakunhod sa load sa memory manager ug nagdugang sa katulin sa programa.

Concurrency ug Concurrency

Ang paralelismo ug kakompetensya sa pinulongan dili madayeg. Wala’y ubos nga lebel nga sinultian nga mahimo bisan sa layo nga makigkompetensya sa Go. Aron mahimong patas, angay nga matikdan nga ang modelo wala giimbento sa mga tagsulat sa pinulongan, apan gihulaman lamang gikan sa maayo nga daan nga ADA nga pinulongan. Ang lengguwahe makahimo sa pagproseso sa milyon-milyon nga parallel nga koneksyon gamit ang tanan nga mga CPU, samtang adunay usa ka han-ay sa kadako nga dili kaayo komplikado nga mga problema sa mga deadlock ug mga kondisyon sa lumba nga kasagaran alang sa multi-threaded code.

Dugang nga mga benepisyo

Kung kini makaganansya, ang tanan mahimong dili hakog.

Ang lengguwahe naghatag usab kanato sa daghang dili maduhaduhaan nga mga benepisyo:

Ang usa ka executable file pagkahuman sa pagtukod sa proyekto labi nga nagpasimple sa pag-deploy sa mga aplikasyon.
Ang static nga pag-type ug type inference makapakunhod pag-ayo sa gidaghanon sa mga sayop sa imong code, bisan kung walay mga pagsulay sa pagsulat. Nahibal-an nako ang pipila ka mga programmer nga wala’y mga pagsulay sa pagsulat ug ang kalidad sa ilang code dili kaayo mag-antos.
Yano kaayo nga cross-compilation ug maayo kaayo nga portability sa standard nga librarya, nga gipasimple kaayo ang pagpalambo sa cross-platform nga mga aplikasyon.
Ang mga regular nga ekspresyon sa RE2 luwas sa hilo ug adunay matag-an nga oras sa pagpatuman.
Usa ka kusgan nga sukaranan nga librarya nga nagtugot sa kadaghanan sa mga proyekto nga mahimo nga wala’y mga balangkas sa ikatulo nga partido.
Gamhanan ang lengguwahe nga makatutok sa problema imbes kung unsaon kini pagsulbad, apan ubos ang lebel nga ang problema masulbad sa episyente.
Ang Go eco system naa na sa mga naugmad nga mga himan nga wala sa kahon para sa tanan nga mga okasyon: mga pagsulay, dokumentasyon, pagdumala sa pakete, kusgan nga linter, henerasyon sa code, detector sa kahimtang sa lumba, ug uban pa.
Ang Go version 1.11 nagpaila sa built-in nga semantic dependency management, nga gitukod sa ibabaw sa sikat nga VCS hosting. Ang tanan nga mga galamiton nga naglangkob sa Go ecosystem naggamit niini nga mga serbisyo sa pag-download, paghimo, ug pag-instalar sa code gikan kanila sa usa ka higayon. Ug maayo kana. Sa pag-abot sa bersyon 1.11, ang problema sa package versioning hingpit usab nga nasulbad.
Tungod kay ang kinauyokan nga ideya sa pinulongan mao ang pagpakunhod sa salamangka, ang pinulongan nagdasig sa mga developers sa pagbuhat sa sayop nga pagdumala sa dayag. Ug kini husto, tungod kay kung dili, makalimtan ra ang bahin sa pagdumala sa sayup. Ang laing butang mao nga kadaghanan sa mga developers tinuyo nga wala magtagad sa pagdumala sa sayop, nga gipalabi imbes sa pagproseso niini nga ipasa lang ang sayop pataas.
Ang lengguwahe wala nagpatuman sa klasikal nga pamaagi sa OOP, tungod kay sa lunsay nga porma niini wala’y virtuality sa Go. Bisan pa, dili kini problema kung mogamit mga interface. Ang pagkawala sa OOP makapakunhod pag-ayo sa babag sa pagsulod alang sa mga nagsugod.

Pagkayano alang sa kaayohan sa komunidad

Sayon ra i-complicate, lisod pasimplehon.

Ang Go gidisenyo nga yano ug kini nagmalampuson sa kana nga katuyoan. Gisulat kini alang sa mga maalamon nga programmer nga nakasabut sa mga benepisyo sa pagtinabangay sa team ug gikapoy sa walay katapusan nga pagkausab sa lebel sa Enterprise nga mga pinulongan. Ang pagbaton usa ka gamay nga hugpong sa mga istruktura sa syntactic sa arsenal niini, halos dili kini mabag-o sa paglabay sa panahon, mao nga ang mga developer adunay daghang oras nga gipagawas alang sa pag-uswag, ug dili alang sa walay katapusan nga pagtuon sa mga pagbag-o sa pinulongan.

Nakadawat usab ang mga kompanya og daghang mga bentaha: ang usa ka mubu nga babag sa pagsulod nagtugot kanila nga dali nga makapangita usa ka espesyalista, ug ang pagkadili mabag-o sa sinultian nagtugot kanila sa paggamit sa parehas nga code bisan pagkahuman sa 10 ka tuig.

konklusyon

Ang dako nga gidak-on sa utok wala gayud makahimo sa bisan unsang elepante nga usa ka mananaog sa Nobel Prize.

Alang sa mga programmer kansang personal nga ego nag-una sa espiritu sa grupo, ingon man ang mga teorista nga nahigugma sa mga hagit sa akademiko ug walay katapusan nga "pag-uswag sa kaugalingon", ang pinulongan dili maayo, tungod kay kini usa ka kinatibuk-ang katuyoan sa artisanal nga pinulongan nga dili motugot kanimo nga makakuha. aesthetic kalipay gikan sa resulta sa imong trabaho ug ipakita ang imong kaugalingon nga propesyonal sa atubangan sa mga kauban (basta atong sukdon ang salabutan pinaagi niini nga mga criteria, ug dili sa IQ). Sama sa tanan sa kinabuhi, kini usa ka butang sa personal nga mga prayoridad. Sama sa tanang mapuslanong mga inobasyon, layo na ang naabot sa pinulongan gikan sa universal denial ngadto sa mass acceptance. Ang lengguwahe maalam sa kayano niini, ug, sama sa imong nahibal-an, ang tanan nga maalam kay simple!

Source: www.habr.com

Ngano nga ang Go dili maayo alang sa mga Unsmart Programmer