Ua kākau ʻia ka ʻatikala ma ke ʻano he pane i kahi i paʻi mua ʻia ʻatikala antipodean.

I loko o ʻelua mau makahiki i hala iho nei ua hoʻohana au iā Go e hoʻokō i kahi kikowaena RADIUS kūikawā me kahi ʻōnaehana pili kālā i kūkulu ʻia. Ma ke ala, ke aʻo nei au i ka paʻakikī o ka ʻōlelo ponoʻī. He mea maʻalahi loa nā papahana a ʻaʻole ia ke kumu o kēia ʻatikala, akā pono ka ʻike o ka hoʻohana ʻana iā Go iā ia iho i kekahi mau huaʻōlelo i kāna pale. Ke lilo nei ʻo Go i ʻōlelo maʻamau no ka code koʻikoʻi, hiki ke hoʻonui ʻia. Ua hana ʻia ka ʻōlelo e Google, kahi i hoʻohana ikaika ʻia ai. ʻO ka laina lalo, manaʻo wau he hewa ka hoʻolālā ʻana o ka ʻōlelo Go no nā polokalamu polokalamu UNintelligent.

Hoʻolālā ʻia no nā polokalamu polokalamu nāwaliwali?

ʻŌlelo nā nāwaliwali i nā pilikia. ʻO ke kamaʻilio ikaika e pili ana i nā manaʻo a me nā moeʻuhane ...

He maʻalahi loa ke aʻo ʻana, maʻalahi hiki iā ʻoe ke heluhelu i ke code me ka ʻole o ke aʻo ʻana. Hoʻohana ʻia kēia hiʻohiʻona o ka ʻōlelo i nā hui honua he nui ke heluhelu pū ʻia ke code me nā loea kumu ʻole (nā luna, nā mea kūʻai aku, etc.). He mea maʻalahi kēia no nā ʻano hana e like me Design Driven Development.
Hoʻomaka nā polokalamu polokalamu hou e hana i nā code kūpono ma hope o hoʻokahi pule a ʻelua paha. ʻO ka puke aʻu i aʻo ai ʻo "Go Programming" (na Mark Summerfield). Maikaʻi ka puke, pili i nā nuances he nui o ka ʻōlelo. Ma hope o nā ʻōlelo paʻakikī ʻole e like me Java, PHP, hōʻoluʻolu ka nele o ka kilokilo. Akā ma hope a ma hope paha, nui nā polokalamu polokalamu liʻiliʻi i ka manaʻo o ka hoʻohana ʻana i nā ala kahiko i kahi kahua hou. He mea pono anei keia?

Ua hoʻokumu ʻo Rob Pike (ka manaʻo nui o ka ʻōlelo) i ka ʻōlelo Go ma ke ʻano he ʻōlelo ʻenehana i maʻalahi ke hoʻomaopopo a hoʻohana pono. Hoʻolālā ʻia ka ʻōlelo no ka hoʻonui ʻana i ka huahana ma nā hui nui a ʻaʻohe kānalua no ia. He nui nā mea polokalamu polokalamu hou e hoʻopiʻi nei he nui nā hiʻohiʻona e nalowale ana lākou. ʻO kēia makemake i ka maʻalahi he hoʻoholo noʻonoʻo ia e nā mea hoʻolālā o ka ʻōlelo, a i mea e hoʻomaopopo pono ai i ke kumu e pono ai, pono mākou e hoʻomaopopo i ka hoʻoikaika ʻana o nā mea hoʻomohala a me kā lākou e hoʻāʻo nei e hoʻokō ma Go.

No laila, no ke aha i maʻalahi ai? Eia kekahi mau huaʻōlelo mai Rob Pike:

ʻO ka mea nui ma ʻaneʻi, ʻaʻole nā mea noiʻi kā mākou papahana. ʻO lākou, ma ke ʻano he ʻōpio, hele mai iā mākou ma hope o ke aʻo ʻana, malia paha ua aʻo lākou iā Java, a i ʻole C/C++, a i ʻole Python. ʻAʻole hiki iā lākou ke hoʻomaopopo i ka ʻōlelo maikaʻi, akā i ka manawa like makemake mākou e hana lākou i nā polokalamu maikaʻi. ʻO ia ke kumu e maʻalahi ai ka ʻōlelo a hoʻomaopopo.

Pono ʻo ia e kamaʻāina, ma ke ʻano like me C. Hoʻomaka ka poʻe papahana e hana ana ma Google i kā lākou ʻoihana a ʻike nui i nā ʻōlelo kaʻina hana, ʻo ia hoʻi ka ʻohana C. ʻO ke koi no ka hoʻohua wikiwiki ʻana i kahi ʻōlelo hoʻolālā hou, ʻaʻole pono ka ʻōlelo ʻino loa.

ʻO nā ʻōlelo naʻauao, ʻaʻole anei?

Nā mea hana o ka maʻalahi

ʻO ka maʻalahi kahi kūlana kūpono no ka nani. Lev Tolstoy.

ʻO ka mālama maʻalahi kekahi o nā pahuhopu koʻikoʻi i kēlā me kēia hoʻolālā. E like me kāu e ʻike ai, ʻo kahi papahana kūpono ʻaʻole ia he papahana kahi ʻaʻohe mea e hoʻohui ai, akā kahi mea ʻaʻohe mea e wehe ai. Manaʻo ka poʻe he nui i mea e hoʻoponopono ai (a hōʻike paha) i nā pilikia paʻakikī, pono kahi mea hana paʻakikī. ʻAʻole naʻe. E lawe kākou i ka ʻōlelo PERL no ka laʻana. Ua manaʻo ka poʻe ʻepekema ʻōlelo he ʻekolu mau ala like ʻole e hoʻoponopono ai i ka pilikia hoʻokahi. He ala ʻē aʻe ka manaʻo o ka ʻōlelo Go; ua hoʻoholo lākou i hoʻokahi ala, akā maikaʻi maoli, lawa ia e hoʻokō ai i ka pahuhopu. He kumu koʻikoʻi kēia ala: ʻo ke ala wale nō ka maʻalahi ke aʻo a paʻakikī hoʻi e poina.

Hoʻopiʻi ka nui o ka poʻe malihini no ka loaʻa ʻole o ka ʻōlelo i nā abstract abstract nani. ʻAe, he ʻoiaʻiʻo kēia, akā ʻo kēia kekahi o nā pono nui o ka ʻōlelo. Loaʻa i ka ʻōlelo ka liʻiliʻi o ke kilokilo - no laila ʻaʻole pono ka ʻike hohonu e heluhelu i ka papahana. E pili ana i ka verbosity o ke code, ʻaʻole pilikia kēia. He polokalamu ʻo Golang i kākau maikaʻi ʻia e heluhelu kū pololei, me ka liʻiliʻi a ʻaʻohe hale. Eia kekahi, ʻoi aku ka wikiwiki o ka heluhelu ʻana i kahi papahana ma mua o ka wikiwiki o ke kākau ʻana. Inā ʻoe e noʻonoʻo i ka hoʻohālikelike ʻana o nā code āpau (hana me ka hoʻohana ʻana i ke kauoha gofmt i kūkulu ʻia), a laila ʻaʻole pilikia ka heluhelu ʻana i kekahi mau laina hou.

ʻAʻole hōʻike nui

ʻAʻole ʻae ʻo Art ke kāohi ʻia kona kūʻokoʻa. ʻAʻole kāna kuleana ka pololei.

Ma muli o ka makemake i ka maʻalahi, nele ʻo Go i nā kūkulu ʻana i nā ʻōlelo ʻē aʻe i ʻike ʻia he mea kūlohelohe e ka poʻe i maʻa iā lākou. I ka wā mua he mea maʻalahi paha ia, akā ʻike ʻoe i ka maʻalahi o ka papahana a ʻoi aku ka maʻalahi o ka heluhelu ʻana.

No ka laʻana, he mea hoʻohana console e heluhelu ana i ka stdin a i ʻole kahi faila mai nā manaʻo laina kauoha e like me kēia:

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

ʻO ka hoʻonā ʻana i ka pilikia like ma D, ʻoiai ʻoi aku ka pōkole, ʻaʻole maʻalahi ka heluhelu ʻana

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

Hell o ke kope kope

Lawe ke kanaka i ka pō i loko ona. Matini Lutera.

Hoʻopiʻi mau ka poʻe hoʻomaka e pili ana iā Go ma ke ʻano o ka nele o nā generics. No ka hoʻoponopono ʻana i kēia pilikia, hoʻohana ka hapa nui o lākou i ke kope kope pololei. No ka laʻana, he hana no ka hōʻuluʻulu ʻana i ka papa inoa o nā integers, manaʻoʻiʻo ka poʻe ʻoihana makemake ʻaʻole hiki ke hoʻokō ʻia ka hana ma nā ʻano ʻē aʻe ma mua o ka hoʻopili kope maʻalahi no kēlā me kēia ʻano ʻikepili.

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

Loaʻa i ka ʻōlelo nā ala e hoʻokō ai i ia mau hana. No ka laʻana, maikaʻi ka polokalamu generic.

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

A, ʻoiai ua ʻoi aku ka lōʻihi o kā mākou code ma mua o ka hihia ma mua, ua lilo ia i mea maʻamau. No laila, ʻaʻole paʻakikī iā mākou ke hoʻokō i nā hana helu helu āpau.

He nui ka poʻe e ʻōlelo he ʻoi aku ka pōkole o kahi papahana ma D, a pololei lākou.

import std.stdio;
import std.algorithm;

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

Eia naʻe, ʻoi aku ka pōkole, akā ʻaʻole i ʻoi aku ka pololei, ʻoiai ʻo ka hoʻokō D ʻaʻole i nānā pono i ka pilikia o ka lawelawe hewa.

Ma ke ola maoli, e like me ka piʻi ʻana o ka paʻakikī o ka noʻonoʻo, e hōʻemi koke ka ʻāpana. ʻOi aku ka wikiwiki o ka pani ʻana i ka wā e pono ai ʻoe e hana i kahi hana hiki ʻole ke hana me ka hoʻohana ʻana i nā mea hoʻohana ʻōlelo maʻamau.

Ma ke ʻano o ka mālama ʻana, hiki ke hoʻonui ʻia, a me ka heluhelu ʻana, i koʻu manaʻo, lanakila ka ʻōlelo Go, ʻoiai e nalowale ana ma ka verbosity.

Hāʻawi ka polokalamu hoʻonohonoho maʻamau i kekahi mau pōmaikaʻi hiki ʻole ke hōʻole ʻia. Hōʻike maopopo ʻia kēia e ka pūʻolo ʻano. No laila, e hoʻokaʻawale i kekahi papa inoa, pono mākou e hoʻokō i ka 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)
}

Inā lawe ʻoe i kekahi papahana open source a holo i ke kauoha grep “interface{}” -R, e ʻike ʻoe i ka pinepine o ka hoʻohana ʻana i nā pilina huikau. E ʻōlelo koke nā hoa pili pili i kēia mau mea ma muli o ka nele o nā generics. Akā naʻe,ʻaʻole kēia i nā manawa a pau. E lawe kākou iā DELPHI i laʻana. ʻOiai ka loaʻa ʻana o kēia mau generics like, aia kekahi ʻano VARIANT kūikawā no nā hana me nā ʻano ʻikepili arbitrary. Hana like ka ʻōlelo Go.

Mai ka pūkuniahi a hiki i nā manu liʻiliʻi

A pono e kūpono ka straitjacket i ka nui o ka pupule. Stanislav Lec.

Manaʻo paha ka nui o ka poʻe pā nui he ʻano hana ʻē aʻe ʻo Go no ka hana ʻana i nā generics - noʻonoʻo. A pololei lākou ... akā i nā hihia kakaikahi wale nō.

Ua ʻōlelo mai ʻo Rob Pike iā mākou:

He mea hana ikaika kēia e hoʻohana me ka akahele. Pono e pale ʻia inā ʻaʻole pono.

Ua haʻi mai ʻo Wikipedia iā mākou i kēia mau mea:

ʻO ka noʻonoʻo e pili ana i ke kaʻina hana e hiki ai i kahi papahana ke nānā a hoʻololi i kona ʻano ponoʻī a me kāna ʻano i ka wā e hoʻokō ai. ʻO ka papahana papahana e pili ana i ka noʻonoʻo ʻana i kapa ʻia ʻo reflective programming. ʻO kēia ke ʻano o ka metaprogramming.

Eia naʻe, e like me kāu e ʻike ai, pono ʻoe e uku no nā mea āpau. I kēia hihia, ʻo ia:

pilikia i ke kākau ʻana i nā papahana
wikiwiki hoʻokō polokalamu

No laila, pono e hoʻohana ʻia ka noʻonoʻo me ka akahele, e like me ka mea kaua nui. ʻO ka hoʻohana noʻonoʻo noʻonoʻo e alakaʻi i nā polokalamu hiki ʻole ke heluhelu ʻia, nā hewa mau a me ka wikiwiki haʻahaʻa. ʻO ka mea wale nō i hiki i ka mea polokalamu snob ke hōʻike i kāna code i mua o nā hoa ʻē aʻe, ʻoi aku ka pragmatic a me ka haʻahaʻa.

Nā ukana moʻomeheu mai Xi? ʻAʻole, mai kekahi mau ʻōlelo!

Me ka waiwai, waiho pū ʻia nā aie i nā hoʻoilina.

ʻOiai ke manaʻoʻiʻo nei ka poʻe he nui ka ʻōlelo ma luna o ka hoʻoilina C, ʻaʻole kēia ka hihia. Hoʻohui ka ʻōlelo i nā ʻano he nui o nā ʻōlelo papahana maikaʻi loa.

Ka Mooolelo O

ʻO ka mea mua, ua hoʻokumu ʻia ka syntax o nā kūkulu grammatical ma ka syntax o ka ʻōlelo C. Eia naʻe, he mana koʻikoʻi ka ʻōlelo DELPHI. No laila, ke ʻike nei mākou ua hoʻopau loa ʻia nā pale ʻē aʻe, e hōʻemi nui ana i ka heluhelu ʻana o ka papahana. Aia i loko o ka ʻōlelo ka mea hoʻohana ":=" i loaʻa i ka ʻōlelo DELPHI. ʻAi ʻia ka manaʻo o nā pūʻolo mai nā ʻōlelo e like me ADA. Ua ʻaiʻē ʻia ka haʻi ʻōlelo o nā hui i hoʻohana ʻole ʻia mai ka ʻōlelo PROLOG.

Semantics

Ua hoʻokumu ʻia nā pūʻolo ma nā semantics o ka ʻōlelo DELPHI. Hoʻopili kēlā me kēia pūʻolo i ka ʻikepili a me ke code a loaʻa i nā hui pilikino a lehulehu. Hāʻawi kēia iā ʻoe e hoʻemi i ke kikowaena pūʻolo i ka liʻiliʻi.

Ua ʻaiʻē ʻia ka hana hoʻokō ma ke ʻano ʻelele mai ka ʻōlelo DELPHI.

Hoʻohui

ʻAʻole me ke kumu ʻole he ʻakaʻaka: Ua hoʻomohala ʻia ʻo Go i ka wā e hōʻuluʻulu ʻia ana kahi papahana C. ʻO kekahi o ka ikaika o ka ʻōlelo, ʻo ia ka hōʻuluʻulu ultra-wikiwiki. Ua ʻaiʻē ʻia ka manaʻo mai ka ʻōlelo DELPHI. Hoʻopili kēlā me kēia pūʻolo Go me kahi module DELPHI. Hoʻopili hou ʻia kēia mau pūʻolo inā pono maoli. No laila, ma hope o ka hoʻoponopono aʻe, ʻaʻole pono ʻoe e hōʻuluʻulu i ka papahana holoʻokoʻa, akā e hōʻuluʻulu hou i nā pūʻolo i hoʻololi ʻia a me nā pūʻolo i hilinaʻi ʻia i kēia mau pūʻulu i hoʻololi ʻia (a ʻo ia hoʻi, inā ua hoʻololi ʻia nā pānaʻi pā).

Nā kūkulu pae kiʻekiʻe

Aia i loko o ka ʻōlelo nā mea kūkulu kiʻekiʻe like ʻole i pili ʻole i nā ʻōlelo haʻahaʻa haʻahaʻa e like me C.

Nā kaula
Nā papa hash
Nā ʻāpana
Ua ʻaiʻē ʻia ka paʻi ʻana mai nā ʻōlelo e like me RUBY (ʻo ka mea pōʻino, ʻaʻole maopopo ka nui a hoʻohana paha i kona hiki piha).

Hoʻoponopono hoʻomanaʻo

Pono ka hoʻokele hoʻomanaʻo i kahi ʻatikala kaʻawale. Inā ma nā ʻōlelo e like me C++, waiho ʻia ka mana i ka mea hoʻomohala, a laila ma nā ʻōlelo hope e like me DELPHI, ua hoʻohana ʻia kahi kumu hoʻohālike helu. Me kēia ala, ʻaʻole i ʻae ʻia nā ʻōlelo kuhikuhi, no ka mea, ua hoʻokumu ʻia nā pūʻulu makua ʻole, a laila ua kūkulu ʻo Go i ka ʻike ʻana o ia mau pūʻulu (e like me C#). Eia kekahi, ʻoi aku ka maikaʻi o ka ʻohi ʻōpala ma mua o ka nui o nā hoʻokō i ʻike ʻia i kēia manawa a hiki ke hoʻohana ʻia no nā hana manawa maoli. Hoʻomaopopo ka ʻōlelo ponoʻī i nā kūlana i hiki ke hoʻokaʻawale ʻia kahi waiwai e mālama ai i kahi hoʻololi ma ka waihona. Hoʻemi kēia i ka ukana ma ka luna hoʻomanaʻo a hoʻonui i ka wikiwiki o ka papahana.

Concurrency and Concurrency

ʻO ka like a me ka hoʻokūkū o ka ʻōlelo ma mua o ka mahalo ʻia. ʻAʻohe ʻōlelo haʻahaʻa hiki ke hoʻokūkū mamao me Go. No ka pololei, pono e hoʻomaopopo ʻaʻole i haku ʻia ke kumu hoʻohālike e nā mea kākau o ka ʻōlelo, akā ua ʻaiʻē wale ʻia mai ka ʻōlelo ADA kahiko maikaʻi. Hiki i ka ʻōlelo ke hoʻoponopono i nā miliona o nā pilina like me ka hoʻohana ʻana i nā CPU āpau, ʻoiai e loaʻa ana kahi kauoha o ka nui o nā pilikia paʻakikī me nā deadlocks a me nā kūlana lāhui i maʻamau no nā code multi-threaded.

Nā pōmaikaʻi hou aku

Inā loaʻa ka waiwai, e lilo nā mea a pau me ka manaʻo ʻole.

Hāʻawi pū ka ʻōlelo iā mākou i nā pono kānalua ʻole:

ʻO kahi faila hiki ke hoʻokō ʻia ma hope o ke kūkulu ʻana i ka papahana e hoʻomaʻamaʻa nui i ka hoʻolaha ʻana o nā noi.
Hiki ke hoʻemi nui ʻia ka helu o nā hewa i kāu code me ka ʻole o ke kākau ʻana i nā hoʻokolohua. ʻIke wau i kekahi mau polokalamu polokalamu e hana me ka ʻole o ke kākau ʻana i nā hoʻokolohua a ʻaʻole pilikia nui ka maikaʻi o kā lākou code.
He mea maʻalahi loa ka hoʻopili ʻana i ke keʻa a me ka hiki ke lawe maikaʻi ʻia o ka waihona maʻamau, e maʻalahi loa i ka hoʻomohala ʻana i nā noi cross-platform.
ʻO nā ʻōlelo maʻamau RE2 he pae-pale a loaʻa nā manawa hoʻokō e wānana.
He waihona maʻamau ikaika e hiki ai i ka hapa nui o nā papahana ke hana me ka ʻole o nā ʻaoʻao ʻekolu.
Ua lawa ka mana o ka ʻōlelo e kālele ai i ka pilikia ma mua o ke ʻano o ka hoʻoponopono ʻana, akā, lawa ka pae haʻahaʻa e hiki ai ke hoʻoponopono maikaʻi ʻia ka pilikia.
Loaʻa i ka ʻōnaehana Go eco nā mea hana i kūkulu ʻia ma waho o ka pahu no nā manawa āpau: nā hoʻāʻo, nā palapala, ka hoʻokele pūʻulu, nā linter ikaika, nā code generation, race condition detector, etc.
Hoʻokomo ʻo Go version 1.11 i ka hoʻokele hilinaʻi semantic i kūkulu ʻia, i kūkulu ʻia ma luna o ka hoʻokipa VCS kaulana. Hoʻohana nā mea hana a pau i loko o ka Go ecosystem i kēia mau lawelawe e hoʻoiho, kūkulu, a hoʻokomo i nā code mai lākou i ka hāʻule hoʻokahi. A maikaʻi kēlā. Me ka hiki ʻana mai o ka mana 1.11, ua hoʻoholo ʻia ka pilikia me ka hoʻololi ʻana i ka pōʻai.
No ka mea ʻo ka manaʻo nui o ka ʻōlelo e hōʻemi i ka kilokilo, hoʻoikaika ka ʻōlelo i nā mea hoʻomohala e hana pololei i ka hana hewa. A pololei kēia, no ka mea, inā ʻaʻole, poina wale ia e pili ana i ka lawelawe hewa ʻana. ʻO kekahi mea ʻē aʻe, ʻo ka hapa nui o nā mea hoʻomohala e haʻalele i ka hana hewa, ʻoi aku ka makemake ma mua o ka hoʻoponopono ʻana iā lākou e hoʻouna wale i ka hewa i luna.
ʻAʻole hoʻokō ka ʻōlelo i ke kaʻina hana OOP maʻamau, no ka mea ma kona ʻano maʻemaʻe ʻaʻohe virtuality i Go. Eia naʻe, ʻaʻole pilikia kēia i ka hoʻohana ʻana i nā interface. ʻO ka nele o OOP e hōʻemi nui i ka pale i ke komo ʻana no ka poʻe hoʻomaka.

ʻO ka maʻalahi no ka pono kaiaulu

He maʻalahi ka paʻakikī, paʻakikī ke maʻalahi.

Ua hoʻolālā ʻia ʻo Go e maʻalahi a kūleʻa i kēlā pahuhopu. Ua kākau ʻia no nā polokalamu polokalamu akamai i hoʻomaopopo i nā pono o ka hui pū ʻana a luhi i ka ʻokoʻa pau ʻole o nā ʻōlelo o Enterprise-level. Loaʻa ka liʻiliʻi liʻiliʻi o nā ʻōnaehana syntactic i kāna arsenal, ʻaʻole hiki ke hoʻololi ʻia i ka manawa, no laila ua hoʻokuʻu ʻia nā mea hoʻomohala no ka hoʻomohala ʻana, ʻaʻole no ke aʻo ʻana i nā ʻōlelo hou.

Loaʻa i nā ʻoihana kekahi mau mea maikaʻi: ʻo kahi pale komo haʻahaʻa e hiki ai iā lākou ke loaʻa koke i kahi loea, a ʻo ka hiki ʻole o ka ʻōlelo e hiki ai iā lākou ke hoʻohana i ka code like ma hope o 10 mau makahiki.

hopena

ʻAʻole i hoʻolilo ka nui o ka lolo i kekahi ʻelepani i lanakila no ka Nobel.

No kēlā poʻe polokalamu polokalamu nona ka manaʻo pilikino ma mua o ka ʻuhane o ka hui, a me ka poʻe theorists makemake i nā pilikia hoʻonaʻauao a me ka pau ʻole o ka "hoʻomaikaʻi ponoʻī", ʻaʻole maikaʻi loa ka ʻōlelo, no ka mea, ʻo ia ka ʻōlelo noʻeau kumu nui ʻaʻole hiki iā ʻoe ke loaʻa. leʻaleʻa nani mai ka hopena o kāu hana a hōʻike iā ʻoe iho i ka ʻoihana i mua o nā hoa hana (inā mākou e ana i ka naʻauao ma kēia mau pae, ʻaʻole ma ka IQ). E like me nā mea a pau i ke ola, he mea ia o nā pono pilikino. E like me nā mea hou kūpono a pau, ua hele lōʻihi ka ʻōlelo mai ka hōʻole honua a hiki i ka ʻae ʻana. He akamai ka ʻōlelo i kona maʻalahi, a, e like me kou ʻike, maʻalahi nā mea akamai a pau!

Source: www.habr.com

No ke aha e hewa ai ʻo Go no nā polokalamu polokalamu ʻole