Ysgrifennwyd yr erthygl fel ymateb i erthygl a gyhoeddwyd yn flaenorol erthygl antipodeaidd.

Dros y ddwy flynedd a mwy diwethaf rwyf wedi bod yn defnyddio Go i weithredu gweinydd RADIUS arbenigol gyda system filio ddatblygedig. Ar hyd y ffordd, rydw i'n dysgu cymhlethdodau'r iaith ei hun. Mae'r rhaglenni eu hunain yn syml iawn ac nid dyna bwrpas yr erthygl hon, ond mae'r profiad o ddefnyddio Go ei hun yn haeddu ychydig eiriau yn ei amddiffyniad. Mae Go yn dod yn iaith gynyddol brif ffrwd ar gyfer cod difrifol, graddadwy. Crëwyd yr iaith gan Google, lle mae'n cael ei defnyddio'n weithredol. Yn y bôn, yr wyf yn onest yn meddwl bod dyluniad yr iaith Go yn ddrwg i raglenwyr UNdeallus.

Wedi'i gynllunio ar gyfer rhaglenwyr gwan?

Mae'r gwan yn siarad am broblemau. Y sgwrs gref am syniadau a breuddwydion...

Mae Go yn hawdd iawn i'w ddysgu, mor hawdd y gallwch chi ddarllen y cod heb fawr ddim hyfforddiant o gwbl. Defnyddir y nodwedd hon o'r iaith mewn llawer o gwmnïau byd-eang, pan ddarllenir y cod ar y cyd ag arbenigwyr nad ydynt yn rhai craidd (rheolwyr, cwsmeriaid, ac ati). Mae hyn yn gyfleus iawn ar gyfer methodolegau fel Datblygu a yrrir gan Ddylunio.
Mae hyd yn oed rhaglenwyr newydd yn dechrau cynhyrchu cod eithaf gweddus ar ôl wythnos neu ddwy. Y llyfr astudiais ohono yw “Go Programming” (gan Mark Summerfield). Mae'r llyfr yn dda iawn, mae'n cyffwrdd â llawer o arlliwiau'r iaith. Ar ôl ieithoedd cymhleth yn ddiangen fel Java, PHP, mae'r diffyg hud yn adfywiol. Ond yn hwyr neu'n hwyrach, mae gan lawer o raglenwyr cyfyngedig y syniad o ddefnyddio hen ddulliau mewn maes newydd. A yw hyn yn wirioneddol angenrheidiol?

Creodd Rob Pike (prif ideolegydd yr iaith) yr iaith Go fel iaith ddiwydiannol sy’n hawdd ei deall ac yn effeithiol i’w defnyddio. Mae'r iaith wedi'i chynllunio ar gyfer y cynhyrchiant mwyaf mewn timau mawr ac nid oes amheuaeth amdani. Mae llawer o raglenwyr newydd yn cwyno bod yna lawer o nodweddion ar goll. Roedd yr awydd hwn am symlrwydd yn benderfyniad ymwybodol gan ddylunwyr yr iaith, ac er mwyn deall yn llawn pam yr oedd ei angen, rhaid inni ddeall cymhelliant y datblygwyr a'r hyn yr oeddent yn ceisio ei gyflawni yn Go.

Felly pam y cafodd ei wneud mor syml? Dyma rai dyfyniadau gan Rob Pike:

Y pwynt allweddol yma yw nad ymchwilwyr yw ein rhaglenwyr. Maen nhw, fel rheol, yn eithaf ifanc, yn dod atom ar ôl astudio, efallai eu bod wedi astudio Java, neu C/C++, neu Python. Ni allant ddeall iaith wych, ond ar yr un pryd rydym am iddynt greu meddalwedd da. Dyna pam y dylai'r iaith fod yn hawdd ei deall a'i dysgu.

Dylai fod yn gyfarwydd, yn fras yn debyg i C. Mae rhaglenwyr sy'n gweithio yn Google yn dechrau eu gyrfaoedd yn gynnar ac maent yn gyfarwydd ar y cyfan ag ieithoedd gweithdrefnol, yn enwedig y teulu C. Mae'r gofyniad am gynhyrchiant cyflym mewn iaith raglennu newydd yn golygu na ddylai'r iaith fod yn rhy radical.

Geiriau doeth, onid ydyn nhw?

Arteffactau Syml

Mae symlrwydd yn amod angenrheidiol ar gyfer harddwch. Lev Tolstoy.

Ei gadw'n syml yw un o'r nodau pwysicaf mewn unrhyw ddyluniad. Fel y gwyddoch, nid yw prosiect perffaith yn brosiect lle nad oes dim i'w ychwanegu, ond yn hytrach yn un nad oes dim i'w dynnu ohono. Mae llawer o bobl yn credu bod angen offeryn cymhleth er mwyn datrys (neu hyd yn oed fynegi) problemau cymhleth. Fodd bynnag, nid yw. Gadewch i ni gymryd yr iaith PERL er enghraifft. Credai ideolegwyr iaith y dylai fod gan raglennydd o leiaf dair ffordd wahanol o ddatrys un broblem. Cymerodd ideolegwyr yr iaith Go lwybr gwahanol; penderfynasant fod un ffordd, ond un dda iawn, yn ddigon i gyrraedd y nod. Mae gan y dull hwn sylfaen ddifrifol: mae'r unig ffordd yn haws i'w dysgu ac yn anoddach ei anghofio.

Mae llawer o ymfudwyr yn cwyno nad yw'r iaith yn cynnwys haniaethau cain. Ydy, mae hyn yn wir, ond dyma un o brif fanteision yr iaith. Mae'r iaith yn cynnwys lleiafswm o hud - felly nid oes angen gwybodaeth ddofn i ddarllen y rhaglen. O ran geirfa'r cod, nid yw hyn yn broblem o gwbl. Mae rhaglen Golang wedi'i hysgrifennu'n dda yn darllen yn fertigol, gydag ychydig neu ddim strwythur. Yn ogystal, mae cyflymder darllen rhaglen o leiaf yn nhrefn maint yn fwy na chyflymder ei hysgrifennu. Os ydych chi'n ystyried bod gan yr holl god fformatio unffurf (wedi'i wneud gan ddefnyddio'r gorchymyn gofmt adeiledig), yna nid yw darllen ychydig o linellau ychwanegol yn broblem o gwbl.

Ddim yn fynegiannol iawn

Ni oddef celfyddyd pan gyfyngir ar ei rhyddid. Nid ei gyfrifoldeb ef yw cywirdeb.

Oherwydd yr awydd am symlrwydd, nid oes gan Go ddyluniadau sydd mewn ieithoedd eraill yn cael eu gweld fel rhywbeth naturiol gan bobl sy'n gyfarwydd â nhw. Ar y dechrau gall fod braidd yn anghyfleus, ond yna byddwch yn sylwi bod y rhaglen yn llawer haws ac yn fwy diamwys i'w darllen.

Er enghraifft, byddai cyfleustodau consol sy'n darllen stdin neu ffeil o ddadleuon llinell orchymyn yn edrych fel hyn:

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

Nid yw'r ateb i'r un broblem yn D, er ei fod yn edrych ychydig yn fyrrach, yn haws i'w ddarllen

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

Uffern o gopïo

Dyn yn cario uffern o fewn ei hun. Martin Luther.

Mae dechreuwyr yn cwyno'n gyson am Go o ran y diffyg generig. I ddatrys y mater hwn, mae'r rhan fwyaf ohonynt yn defnyddio copïo cod uniongyrchol. Er enghraifft, swyddogaeth ar gyfer crynhoi rhestr o gyfanrifau, mae darpar weithwyr proffesiynol o'r fath yn credu na ellir gweithredu'r swyddogaeth mewn unrhyw ffordd arall na thrwy gludo copi syml ar gyfer pob math o ddata.

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

Mae gan yr iaith ddigon o fodd i weithredu strwythurau o'r fath. Er enghraifft, byddai rhaglennu generig yn iawn.

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

Ac, er bod ein cod wedi troi allan i fod ychydig yn hirach na'r achos blaenorol, mae wedi dod yn gyffredinol. Felly, ni fydd yn anodd inni roi pob gweithrediad rhifyddol ar waith.

Bydd llawer yn dweud bod rhaglen yn D yn edrych yn sylweddol fyrrach, a byddant yn iawn.

import std.stdio;
import std.algorithm;

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

Fodd bynnag, dim ond yn fyrrach, ond nid yn fwy cywir, gan fod gweithrediad D yn anwybyddu problem trin gwallau yn llwyr.

Mewn bywyd go iawn, wrth i gymhlethdod rhesymeg gynyddu, mae'r bwlch yn culhau'n gyflym. Mae'r bwlch yn cau'n gyflymach fyth pan fydd angen i chi gyflawni gweithred na ellir ei chyflawni gan ddefnyddio gweithredwyr iaith safonol.

O ran cynaladwyedd, estynadwyedd, a darllenadwyedd, yn fy marn i, yr iaith Go sy'n ennill, er ei bod yn colli mewn geirfa.

Mae rhaglennu cyffredinol mewn rhai achosion yn rhoi buddion diymwad i ni. Dangosir hyn yn glir gan y pecyn didoli. Felly, i ddidoli unrhyw restr, mae angen i ni weithredu'r rhyngwyneb 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)
}

Os cymerwch unrhyw brosiect ffynhonnell agored a rhedeg y gorchymyn grep “interface{}” -R, fe welwch pa mor aml y defnyddir rhyngwynebau dryslyd. Bydd cymrodyr agos eu meddwl yn dweud ar unwaith mai diffyg generig sy'n gyfrifol am hyn i gyd. Fodd bynnag, nid yw hyn bob amser yn wir. Gadewch i ni gymryd DELPHI fel enghraifft. Er gwaethaf presenoldeb yr un generig hyn, mae'n cynnwys math AMRYWIOL arbennig ar gyfer gweithrediadau gyda mathau data mympwyol. Mae'r iaith Go yn gwneud yr un peth.

O fagnel i adar y to

A rhaid i'r straitjacket ffitio maint y gwallgofrwydd. Stanislav Lec.

Efallai y bydd llawer o gefnogwyr eithafol yn honni bod gan Go fecanwaith arall ar gyfer creu generig - adlewyrchiad. A byddant yn iawn ... ond dim ond mewn achosion prin.

Mae Rob Pike yn ein rhybuddio:

Mae hwn yn offeryn pwerus y dylid ei ddefnyddio gyda gofal. Dylid ei osgoi oni bai ei fod yn gwbl angenrheidiol.

Mae Wikipedia yn dweud y canlynol wrthym:

Mae myfyrdod yn cyfeirio at y broses lle gall rhaglen fonitro ac addasu ei strwythur a'i hymddygiad ei hun wrth gyflawni. Gelwir y patrwm rhaglennu adlewyrchiad sylfaenol yn rhaglennu adlewyrchol. Mae hwn yn fath o fetaraglennu.

Fodd bynnag, fel y gwyddoch, mae'n rhaid i chi dalu am bopeth. Yn yr achos hwn, mae'n:

anhawster wrth ysgrifennu rhaglenni
cyflymder gweithredu rhaglen

Felly, rhaid bod yn ofalus wrth fyfyrio, fel arf o safon uchel. Mae defnydd difeddwl o fyfyrio yn arwain at raglenni annarllenadwy, gwallau cyson a chyflymder isel. Dim ond y peth i raglennydd snob allu dangos ei god o flaen cydweithwyr eraill, mwy pragmatig a diymhongar.

Bagiau diwylliannol o Xi? Na, o nifer o ieithoedd!

Ynghyd â'r ffortiwn, mae dyledion hefyd yn cael eu gadael i'r etifeddion.

Er gwaethaf y ffaith bod llawer yn credu bod yr iaith wedi'i seilio'n gyfan gwbl ar y dreftadaeth C, nid yw hyn yn wir. Mae'r iaith yn ymgorffori llawer o agweddau ar yr ieithoedd rhaglennu gorau.

cystrawen

Yn gyntaf oll, mae cystrawen strwythurau gramadegol yn seiliedig ar gystrawen yr iaith C. Fodd bynnag, roedd gan yr iaith DELPHI ddylanwad arwyddocaol hefyd. Felly, gwelwn fod y cromfachau segur, sy'n lleihau darllenadwyedd y rhaglen yn fawr, wedi'u dileu'n llwyr. Mae'r iaith hefyd yn cynnwys y gweithredwr “:=” sy'n gynhenid i iaith DELPHI. Mae'r cysyniad o becynnau yn cael ei fenthyg o ieithoedd fel ADA. Mae'r datganiad o endidau nas defnyddiwyd yn cael ei fenthyg o'r iaith PROLOG.

Semanteg

Seiliwyd y pecynnau ar semanteg yr iaith DELPHI. Mae pob pecyn yn crynhoi data a chod ac yn cynnwys endidau preifat a chyhoeddus. Mae hyn yn caniatáu ichi leihau'r rhyngwyneb pecyn i'r lleiafswm.

Benthycwyd y dull gweithredu trwy ddirprwyo o iaith DELPHI.

Llunio

Nid heb reswm mae jôc: datblygwyd Go tra roedd rhaglen C yn cael ei llunio. Un o gryfderau'r iaith yw ei chasgliad tra chyflym. Benthycwyd y syniad o'r iaith DELPHI. Mae pob pecyn Go yn cyfateb i fodiwl DELPHI. Dim ond pan fo gwir angen y caiff y pecynnau hyn eu hail-grynhoi. Felly, ar ôl y golygiad nesaf, nid oes angen i chi lunio'r rhaglen gyfan, ond yn hytrach ail-grynhoi'r pecynnau a'r pecynnau newydd sy'n dibynnu ar y pecynnau hyn sydd wedi'u newid yn unig (a hyd yn oed wedyn, dim ond os yw'r rhyngwynebau pecyn wedi newid).

Adeiladau lefel uchel

Mae'r iaith yn cynnwys llawer o wahanol luniadau lefel uchel nad ydynt mewn unrhyw ffordd yn gysylltiedig ag ieithoedd lefel isel fel C.

Llinellau
Byrddau hash
Sleisys
Mae teipio hwyaid yn cael ei fenthyg o ieithoedd fel RUBY (nad yw llawer, yn anffodus, yn deall nac yn ei ddefnyddio i'w lawn botensial).

Rheoli cof

Yn gyffredinol, mae rheoli cof yn haeddu erthygl ar wahân. Os mewn ieithoedd fel C ++, mae rheolaeth yn cael ei adael yn llwyr i'r datblygwr, yna mewn ieithoedd diweddarach fel DELPHI, defnyddiwyd model cyfrif cyfeiriadau. Gyda'r dull hwn, ni chaniatawyd cyfeiriadau cylchol, ers i glystyrau amddifad gael eu ffurfio, yna mae Go wedi ymgorffori canfod clystyrau o'r fath (fel C#). Yn ogystal, mae'r casglwr sbwriel yn fwy effeithlon na'r rhan fwyaf o weithrediadau hysbys ar hyn o bryd a gellir ei ddefnyddio eisoes ar gyfer llawer o dasgau amser real. Mae'r iaith ei hun yn cydnabod sefyllfaoedd lle gellir dyrannu gwerth i storio newidyn ar y pentwr. Mae hyn yn lleihau'r llwyth ar y rheolwr cof ac yn cynyddu cyflymder y rhaglen.

Concurrency a Concurrency

Mae cyfochrogrwydd a chystadleurwydd yr iaith y tu hwnt i ganmoliaeth. Ni all unrhyw iaith lefel isel hyd yn oed gystadlu o bell â Go. A bod yn deg, mae'n werth nodi na chafodd y model ei ddyfeisio gan awduron yr iaith, ond yn hytrach ei fenthyg o'r hen iaith ADA dda. Mae'r iaith yn gallu prosesu miliynau o gysylltiadau cyfochrog gan ddefnyddio pob CPUs, tra'n cael trefn maint problemau llai cymhleth gyda deadlocks ac amodau hil sy'n nodweddiadol ar gyfer cod aml-edau.

Buddion ychwanegol

Os yw'n broffidiol, bydd pawb yn dod yn anhunanol.

Mae iaith hefyd yn rhoi nifer o fanteision diamheuol inni:

Mae un ffeil gweithredadwy ar ôl adeiladu'r prosiect yn symleiddio'r defnydd o geisiadau yn fawr.
Gall teipio statig a chasgliad teip leihau nifer y gwallau yn eich cod yn sylweddol, hyd yn oed heb ysgrifennu profion. Rwy'n gwybod rhai rhaglenwyr sy'n gwneud heb ysgrifennu profion o gwbl ac nid yw ansawdd eu cod yn dioddef yn sylweddol.
Traws-grynhoi syml iawn a hygludedd rhagorol y llyfrgell safonol, sy'n symleiddio datblygiad cymwysiadau traws-lwyfan yn fawr.
Mae mynegiadau rheolaidd RE2 yn edau-ddiogel ac mae ganddynt amseroedd gweithredu rhagweladwy.
Llyfrgell safonol bwerus sy'n caniatáu i'r mwyafrif o brosiectau wneud heb fframweithiau trydydd parti.
Mae'r iaith yn ddigon pwerus i ganolbwyntio ar y broblem yn hytrach na sut i'w datrys, ond eto ar lefel isel y gellir datrys y broblem yn effeithlon.
Mae system Go eco eisoes yn cynnwys offer datblygedig allan o'r bocs ar gyfer pob achlysur: profion, dogfennaeth, rheoli pecynnau, linters pwerus, cynhyrchu cod, synhwyrydd amodau hil, ac ati.
Cyflwynodd fersiwn Go 1.11 reolaeth dibyniaeth semantig adeiledig, wedi'i adeiladu ar ben cynnal VCS poblogaidd. Mae'r holl offer sy'n rhan o ecosystem Go yn defnyddio'r gwasanaethau hyn i lawrlwytho, adeiladu a gosod cod ohonynt mewn un swoop. Ac mae hynny'n wych. Gyda dyfodiad fersiwn 1.11, cafodd y broblem gyda fersiwn pecyn ei datrys yn llwyr hefyd.
Oherwydd mai syniad craidd yr iaith yw lleihau hud, mae'r iaith yn cymell datblygwyr i drin gwallau yn benodol. Ac mae hyn yn gywir, oherwydd fel arall, bydd yn anghofio trin gwallau yn gyfan gwbl. Peth arall yw bod y rhan fwyaf o ddatblygwyr yn anwybyddu trin gwallau yn fwriadol, gan ddewis yn hytrach na'u prosesu i anfon y gwall ymlaen i fyny.
Nid yw'r iaith yn gweithredu'r fethodoleg OOP glasurol, oherwydd yn ei ffurf bur nid oes rhithwiredd yn Go. Fodd bynnag, nid yw hyn yn broblem wrth ddefnyddio rhyngwynebau. Mae absenoldeb OOP yn lleihau'n sylweddol y rhwystr rhag mynediad i ddechreuwyr.

Symlrwydd er budd y gymuned

Mae'n hawdd ei gymhlethu, yn anodd ei symleiddio.

Cynlluniwyd Go i fod yn syml ac mae'n llwyddo ar y nod hwnnw. Fe'i hysgrifennwyd ar gyfer rhaglenwyr craff sy'n deall manteision gwaith tîm ac sydd wedi blino ar amrywioldeb diddiwedd ieithoedd lefel Menter. Gyda set gymharol fach o strwythurau cystrawennol yn ei arsenal, yn ymarferol nid yw'n destun newidiadau dros amser, felly mae datblygwyr yn cael llawer o amser yn rhydd i'w datblygu, ac nid ar gyfer astudio arloesiadau iaith yn ddiddiwedd.

Mae cwmnïau hefyd yn derbyn nifer o fanteision: mae rhwystr mynediad isel yn caniatáu iddynt ddod o hyd i arbenigwr yn gyflym, ac mae ansefydlogrwydd yr iaith yn caniatáu iddynt ddefnyddio'r un cod hyd yn oed ar ôl 10 mlynedd.

Casgliad

Nid yw maint ymennydd mawr erioed wedi gwneud unrhyw eliffant yn enillydd Gwobr Nobel.

I'r rhaglenwyr hynny y mae eu hego personol yn cael blaenoriaeth dros ysbryd tîm, yn ogystal â damcaniaethwyr sy'n caru heriau academaidd a "hunan-welliant" diddiwedd, mae'r iaith yn ddrwg iawn, gan ei bod yn iaith artisanal pwrpas cyffredinol nad yw'n caniatáu ichi gael pleser esthetig o ganlyniad eich gwaith a dangoswch eich hun yn broffesiynol o flaen cydweithwyr (ar yr amod ein bod yn mesur gwybodaeth yn ôl y meini prawf hyn, ac nid yn ôl IQ). Fel popeth mewn bywyd, mae'n fater o flaenoriaethau personol. Fel pob arloesedd gwerth chweil, mae'r iaith eisoes wedi dod yn bell o wadu cyffredinol i dderbyniad torfol. Mae'r iaith yn ddyfeisgar yn ei symlrwydd, ac, fel y gwyddoch, mae popeth dyfeisgar yn syml!

Ffynhonnell: hab.com

Mae Pam Ewch yn Ddrwg i Raglenwyr Ansmart