Nakala hiyo iliandikwa kama jibu kwa iliyochapishwa hapo awali makala ya antipodean.

Kwa muda wa miaka miwili pamoja na iliyopita nimekuwa nikitumia Go kutekeleza seva maalum ya RADIUS iliyo na mfumo wa utozaji uliotengenezwa. Njiani, ninajifunza ugumu wa lugha yenyewe. Mipango yenyewe ni rahisi sana na sio madhumuni ya makala hii, lakini uzoefu wa kutumia Go yenyewe unastahili maneno machache katika utetezi wake. Go inazidi kuwa lugha ya kawaida kwa msimbo mbaya, unaoweza kuongezeka. Lugha iliundwa na Google, ambapo inatumika kikamilifu. Jambo la msingi, nadhani kwa uaminifu kwamba muundo wa lugha ya Go ni mbaya kwa waandaaji programu wasio na akili.

Je, imeundwa kwa ajili ya watayarishaji programu dhaifu?

Wanyonge wanazungumza juu ya shida. Mazungumzo makali juu ya mawazo na ndoto ...

Go ni rahisi sana kujifunza, ni rahisi sana kwamba unaweza kusoma msimbo bila mafunzo yoyote. Kipengele hiki cha lugha kinatumika katika makampuni mengi ya kimataifa wakati msimbo unasomwa pamoja na wataalamu wasio wa msingi (wasimamizi, wateja, n.k.). Hii ni rahisi sana kwa mbinu kama vile Ubunifu Unaoendeshwa na Ubunifu.
Hata waandaaji wa programu za novice huanza kutoa nambari nzuri kabisa baada ya wiki moja au mbili. Kitabu nilichojifunza ni "Go Programming" (cha Mark Summerfield). Kitabu ni kizuri sana, kinagusa nuances nyingi za lugha. Baada ya lugha ngumu isiyo ya lazima kama Java, PHP, ukosefu wa uchawi unaburudisha. Lakini mapema au baadaye, watengenezaji programu wengi wenye ukomo wana wazo la kutumia njia za zamani katika uwanja mpya. Je, hii ni lazima kweli?

Rob Pike (mtaalamu mkuu wa lugha) aliunda lugha ya Go kama lugha ya kiviwanda ambayo ni rahisi kueleweka na kutumia vizuri. Lugha imeundwa kwa tija kubwa katika timu kubwa na hakuna shaka juu yake. Watengenezaji programu wengi wa novice wanalalamika kwamba kuna vipengele vingi ambavyo wanakosa. Tamaa hii ya usahili ilikuwa uamuzi wa kufahamu wa wabunifu wa lugha, na ili kuelewa kikamilifu kwa nini ilihitajika, ni lazima tuelewe motisha ya wasanidi programu na kile walichokuwa wakijaribu kufikia katika Go.

Kwa hivyo kwa nini ilifanywa rahisi sana? Hapa kuna nukuu kadhaa kutoka kwa Rob Pike:

Jambo kuu hapa ni kwamba watengenezaji programu wetu sio watafiti. Wao ni, kama sheria, wachanga kabisa, wanakuja kwetu baada ya kusoma, labda walisoma Java, au C / C ++, au Python. Hawawezi kuelewa lugha kubwa, lakini wakati huo huo tunataka watengeneze programu nzuri. Ndiyo maana lugha inapaswa kuwa rahisi kuelewa na kujifunza.

Anapaswa kuwa mzoefu, anayezungumza takriban sawa na C. Watayarishaji programu wanaofanya kazi katika Google huanza taaluma zao mapema na mara nyingi wanafahamu lugha za kitaratibu, hasa familia ya C. Mahitaji ya tija ya haraka katika lugha mpya ya programu inamaanisha kuwa lugha haipaswi kuwa kali sana.

Maneno ya busara, sivyo?

Mabaki ya Usahili

Unyenyekevu ni hali ya lazima kwa uzuri. Lev Tolstoy.

Kuiweka rahisi ni moja ya malengo muhimu zaidi katika muundo wowote. Kama unavyojua, mradi kamili sio mradi ambao hakuna cha kuongeza, lakini moja ambayo hakuna kitu cha kuondoa. Watu wengi wanaamini kwamba ili kutatua (au hata kueleza) matatizo magumu, chombo ngumu kinahitajika. Hata hivyo, sivyo. Wacha tuchukue lugha ya PERL kwa mfano. Wataalamu wa itikadi za lugha waliamini kwamba mpanga programu anapaswa kuwa na angalau njia tatu tofauti za kutatua tatizo moja. Wanaitikadi wa lugha ya Go walichukua njia tofauti; waliamua kwamba njia moja, lakini nzuri sana, ilitosha kufikia lengo. Njia hii ina msingi mkubwa: njia pekee ni rahisi kujifunza na vigumu kusahau.

Wahamiaji wengi wanalalamika kwamba lugha hiyo haina vifupisho vya kifahari. Ndio, hii ni kweli, lakini hii ni moja ya faida kuu za lugha. Lugha ina kiwango cha chini cha uchawi - kwa hivyo hakuna maarifa ya kina inahitajika kusoma programu. Kuhusu kitenzi cha msimbo, hili sio tatizo hata kidogo. Programu ya Golang iliyoandikwa vizuri inasomwa kwa wima, ikiwa na muundo mdogo au bila kabisa. Kwa kuongeza, kasi ya kusoma programu ni angalau amri ya ukubwa zaidi kuliko kasi ya kuandika. Ikiwa unazingatia kwamba msimbo wote una muundo sawa (uliofanywa kwa kutumia amri ya gofmt iliyojengwa), basi kusoma mistari michache ya ziada sio tatizo kabisa.

Sio kujieleza sana

Sanaa haivumilii wakati uhuru wake umebanwa. Usahihi sio jukumu lake.

Kwa sababu ya hamu ya unyenyekevu, Go inakosa miundo ambayo kwa lugha zingine inachukuliwa kuwa kitu cha asili na watu waliozoea. Mara ya kwanza inaweza kuwa haifai, lakini basi unaona kwamba programu ni rahisi zaidi na inaeleweka zaidi kusoma.

Kwa mfano, matumizi ya koni ambayo inasoma stdin au faili kutoka kwa hoja za mstari wa amri ingeonekana kama hii:

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

Suluhisho la shida sawa katika D, ingawa inaonekana fupi kwa kiasi fulani, sio rahisi kusoma

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

Kuzimu ya kuiga

Mwanadamu hubeba jehanamu ndani yake. Martin Luther.

Kompyuta hulalamika kila mara kuhusu Nenda kwa suala la ukosefu wa jenetiki. Ili kutatua suala hili, wengi wao hutumia kunakili nambari moja kwa moja. Kwa mfano, chaguo la kukokotoa la kujumlisha orodha ya nambari kamili, wataalamu kama hao wanaamini kuwa utendakazi hauwezi kutekelezwa kwa njia nyingine yoyote isipokuwa kwa kubandika kwa nakala rahisi kwa kila aina ya data.

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

Lugha ina nyenzo za kutosha kutekeleza miundo kama hii. Kwa mfano, programu ya generic itakuwa sawa.

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

Na, ingawa nambari yetu iligeuka kuwa ndefu zaidi kuliko kesi ya awali, imekuwa ya jumla. Kwa hiyo, haitakuwa vigumu kwetu kutekeleza shughuli zote za hesabu.

Wengi watasema kuwa mpango katika D unaonekana mfupi sana, na watakuwa sawa.

import std.stdio;
import std.algorithm;

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

Hata hivyo, ni mfupi tu, lakini si sahihi zaidi, kwani utekelezaji wa D hupuuza kabisa tatizo la kushughulikia makosa.

Katika maisha halisi, jinsi ugumu wa mantiki unavyoongezeka, pengo hupungua haraka. Pengo huziba kwa haraka zaidi unapohitaji kufanya kitendo ambacho hakiwezi kufanywa kwa kutumia viendeshaji lugha sanifu.

Kwa upande wa udumishaji, upanuzi, na usomaji, kwa maoni yangu, lugha ya Go inashinda, ingawa inapoteza katika kitenzi.

Upangaji programu wa jumla katika hali zingine hutupatia faida zisizoweza kupingwa. Hii inaonyeshwa wazi na kifurushi cha kupanga. Kwa hivyo, kupanga orodha yoyote, tunahitaji tu kutekeleza kiolesura cha 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)
}

Ukichukua mradi wowote wa chanzo huria na kuendesha amri ya grep "interface{}" -R, utaona ni mara ngapi miingiliano ya kutatanisha inatumiwa. Wandugu wenye nia ya karibu watasema mara moja kwamba yote haya ni kwa sababu ya ukosefu wa jenetiki. Hata hivyo, hii sio wakati wote. Hebu tuchukue mfano wa Delphi. Licha ya kuwepo kwa jenetiki hizi, ina aina maalum ya VARIANT kwa uendeshaji na aina za data kiholela. Lugha ya Go hufanya vivyo hivyo.

Kutoka kwa kanuni hadi shomoro

Na straitjacket lazima ilingane na saizi ya wazimu. Stanislav Lec.

Mashabiki wengi waliokithiri wanaweza kudai kuwa Go ina utaratibu mwingine wa kuunda jenetiki - tafakari. Na watakuwa sawa ... lakini tu katika hali nadra.

Rob Pike anatuonya:

Hii ni zana yenye nguvu ambayo inapaswa kutumika kwa tahadhari. Inapaswa kuepukwa isipokuwa lazima madhubuti.

Wikipedia inatuambia yafuatayo:

Tafakari inarejelea mchakato ambapo programu inaweza kufuatilia na kurekebisha muundo na tabia yake wakati wa utekelezaji. Mtazamo wa utayarishaji wa tafakari ya msingi inaitwa programu ya kuakisi. Hii ni aina ya metaprogramming.

Walakini, kama unavyojua, lazima ulipe kila kitu. Katika kesi hii ni:

ugumu wa kuandika programu
kasi ya utekelezaji wa programu

Kwa hivyo, kutafakari lazima kutumike kwa tahadhari, kama silaha ya caliber kubwa. Matumizi ya kutafakari bila kufikiri husababisha programu zisizoweza kusomeka, makosa ya mara kwa mara na kasi ya chini. Jambo pekee kwa mpangaji programu wa snob kuwa na uwezo wa kuonyesha msimbo wake mbele ya wenzake wengine, pragmatiki zaidi na wa kawaida.

Mizigo ya kitamaduni kutoka Xi? Hapana, kutoka kwa idadi ya lugha!

Pamoja na bahati, deni pia huachwa kwa warithi.

Licha ya ukweli kwamba wengi wanaamini kwamba lugha inategemea kabisa urithi wa C, hii sivyo. Lugha inajumuisha vipengele vingi vya lugha bora za programu.

syntax

Kwanza kabisa, sintaksia ya miundo ya kisarufi inatokana na sintaksia ya lugha C. Hata hivyo, lugha ya DELPI pia ilikuwa na ushawishi mkubwa. Kwa hivyo, tunaona kwamba mabano yasiyo ya kawaida, ambayo hupunguza sana usomaji wa programu, yameondolewa kabisa. Lugha pia ina opereta ":=" asili ya lugha ya DELPHI. Wazo la vifurushi hukopwa kutoka kwa lugha kama ADA. Tangazo la huluki ambazo hazijatumika hukopwa kutoka kwa lugha ya PROLOG.

Semantiki

Vifurushi vilitokana na semantiki ya lugha ya DELPHI. Kila kifurushi kinajumuisha data na msimbo na kina huluki za kibinafsi na za umma. Hii hukuruhusu kupunguza kiolesura cha kifurushi kwa kiwango cha chini.

Operesheni ya utekelezaji kwa mbinu ya ugawaji ilikopwa kutoka kwa lugha ya DELPHI.

Mkusanyiko

Sio bila sababu kwamba kuna mzaha: Go ilitengenezwa wakati programu ya C ilikuwa ikitungwa. Moja ya nguvu za lugha ni mkusanyiko wake wa haraka sana. Wazo lilikopwa kutoka kwa lugha ya DELPHI. Kila kifurushi cha Go kinalingana na moduli ya DELPI. Vifurushi hivi vinakusanywa tena wakati inahitajika sana. Kwa hivyo, baada ya hariri inayofuata, hauitaji kuunda programu nzima, lakini badala yake kusanya vifurushi na vifurushi vilivyobadilishwa ambavyo hutegemea vifurushi hivi vilivyobadilishwa (na hata wakati huo, tu ikiwa miingiliano ya kifurushi imebadilika).

Ubunifu wa hali ya juu

Lugha ina miundo mingi tofauti ya kiwango cha juu ambayo haihusiani kwa vyovyote na lugha za kiwango cha chini kama C.

Kamba
Jedwali la hash
Vipande
Kuandika kwa bata hukopwa kutoka kwa lugha kama RUBY (ambayo, kwa bahati mbaya, wengi hawaelewi au kutumia kwa uwezo wake kamili).

Usimamizi wa kumbukumbu

Usimamizi wa kumbukumbu kwa ujumla unastahili nakala tofauti. Ikiwa katika lugha kama C++, udhibiti umeachwa kwa msanidi programu, basi katika lugha za baadaye kama DELPHI, mtindo wa kuhesabu kumbukumbu ulitumiwa. Kwa mbinu hii, marejeleo ya mzunguko hayakuruhusiwa, kwa kuwa vikundi vya watoto yatima viliundwa, basi Go ina ugunduzi wa ndani wa nguzo kama hizo (kama C #). Kwa kuongeza, mtoaji wa takataka ni bora zaidi kuliko utekelezaji unaojulikana sasa na unaweza tayari kutumika kwa kazi nyingi za wakati halisi. Lugha yenyewe inatambua hali wakati thamani ya kuhifadhi kigezo inaweza kugawiwa kwenye rafu. Hii inapunguza mzigo kwenye meneja wa kumbukumbu na huongeza kasi ya programu.

Concurrency na Concurrency

Usambamba na ushindani wa lugha ni zaidi ya sifa. Hakuna lugha ya kiwango cha chini inayoweza hata kushindana kwa mbali na Go. Ili kuwa sawa, inafaa kuzingatia kwamba mfano huo haukuzuliwa na waandishi wa lugha, lakini ulikopwa tu kutoka kwa lugha nzuri ya zamani ya ADA. Lugha ina uwezo wa kuchakata mamilioni ya miunganisho sambamba kwa kutumia CPU zote, huku ikiwa na mpangilio wa matatizo changamano yenye mikwamo na masharti ya mbio ambayo ni ya kawaida kwa misimbo yenye nyuzi nyingi.

Faida za ziada

Ikiwa ni faida, kila mtu atakuwa asiye na ubinafsi.

Lugha pia hutupatia idadi ya faida zisizo na shaka:

Faili moja inayoweza kutekelezwa baada ya kujenga mradi hurahisisha sana upelekaji wa programu.
Kuandika tuli na uelekezaji wa aina kunaweza kupunguza kwa kiasi kikubwa idadi ya makosa katika msimbo wako, hata bila kuandika majaribio. Ninajua waandaaji wa programu ambao hufanya bila kuandika majaribio hata kidogo na ubora wa nambari zao hauteseka sana.
Ujumuishaji rahisi sana na uwezo bora wa kubebeka wa maktaba ya kawaida, ambayo hurahisisha sana ukuzaji wa utumizi wa majukwaa mtambuka.
Semi za kawaida za RE2 ni salama kwa nyuzi na zina nyakati za utekelezaji zinazotabirika.
Maktaba ya kawaida yenye nguvu ambayo inaruhusu miradi mingi kufanya bila mifumo ya wahusika wengine.
Lugha ina uwezo wa kutosha kuzingatia tatizo badala ya jinsi ya kulitatua, lakini ni ya kiwango cha chini kiasi kwamba tatizo linaweza kutatuliwa kwa ufanisi.
Mfumo wa Go eco tayari una zana zilizotengenezwa nje ya kisanduku kwa matukio yote: majaribio, uwekaji hati, udhibiti wa vifurushi, linter zenye nguvu, uzalishaji wa msimbo, kitambua hali ya mbio, n.k.
Toleo la Go 1.11 lilianzisha usimamizi wa utegemezi wa kisemantiki uliojengewa ndani, uliojengwa juu ya upangishaji maarufu wa VCS. Zana zote zinazounda mfumo ikolojia wa Go hutumia huduma hizi kupakua, kujenga, na kusakinisha msimbo kutoka kwazo kwa haraka haraka. Na hiyo ni nzuri. Kwa kuwasili kwa toleo la 1.11, tatizo la utayarishaji wa kifurushi pia lilitatuliwa kabisa.
Kwa sababu wazo kuu la lugha ni kupunguza uchawi, lugha inawapa motisha wasanidi programu kushughulikia makosa kwa uwazi. Na hii ni sahihi, kwa sababu vinginevyo, itasahau tu juu ya utunzaji wa makosa kabisa. Jambo lingine ni kwamba watengenezaji wengi hupuuza kwa makusudi ushughulikiaji wa makosa, wakipendelea badala ya kuyachakata ili kusambaza kosa juu zaidi.
Lugha haitekelezi mbinu ya kitamaduni ya OOP, kwani katika hali yake safi hakuna uhalisi katika Go. Walakini, hii sio shida wakati wa kutumia miingiliano. Kutokuwepo kwa OOP kunapunguza kwa kiasi kikubwa kizuizi cha kuingia kwa wanaoanza.

Urahisi kwa manufaa ya jamii

Ni rahisi kugumu, ngumu kurahisisha.

Go iliundwa kuwa rahisi na inafanikiwa kwa lengo hilo. Iliandikwa kwa ajili ya watengenezaji programu mahiri wanaoelewa manufaa ya kazi ya pamoja na wamechoshwa na utofauti usioisha wa lugha za kiwango cha Biashara. Kuwa na seti ndogo ya miundo ya kisintaksia kwenye safu yake ya ushambuliaji, haiko chini ya mabadiliko kwa wakati, kwa hivyo watengenezaji wana wakati mwingi wa kuachiliwa kwa maendeleo, na sio kwa kusoma uvumbuzi wa lugha bila mwisho.

Makampuni pia hupokea faida kadhaa: kizuizi cha chini cha kuingia kinawawezesha kupata mtaalamu haraka, na kutobadilika kwa lugha huwawezesha kutumia kanuni sawa hata baada ya miaka 10.

Hitimisho

Ukubwa mkubwa wa ubongo haujawahi kumfanya tembo yeyote kuwa mshindi wa Tuzo ya Nobel.

Kwa wale waandaaji wa programu ambao ubinafsi wao unatanguliwa kuliko roho ya timu, na vile vile wananadharia wanaopenda changamoto za kitaaluma na "kujiboresha" bila mwisho, lugha ni mbaya sana, kwani ni lugha ya ufundi ya kusudi la jumla ambayo haikuruhusu kupata. raha ya kupendeza kutoka kwa matokeo ya kazi yako na ujionyeshe kuwa mtaalamu mbele ya wenzako (mradi tunapima akili kwa vigezo hivi, na sio kwa IQ). Kama kila kitu maishani, ni suala la vipaumbele vya kibinafsi. Kama ubunifu wote muhimu, lugha tayari imetoka kwa kunyimwa hadi kukubalika kwa watu wengi. Lugha ni ya busara katika unyenyekevu wake, na, kama unavyojua, kila kitu cha busara ni rahisi!

Chanzo: mapenzi.com

Kwa nini Go ni Mbaya kwa Watengenezaji Programu Wasio na akili