abclinuxu.cz AbcLinuxu.cz itbiz.cz ITBiz.cz HDmag.cz HDmag.cz abcprace.cz AbcPráce.cz
AbcLinuxu hledá autory!
Inzerujte na AbcPráce.cz od 950 Kč
Rozšířené hledání
×

dnes 01:44 | Zajímavý projekt

Kampaň na podporu chytrého telefonu Librem 5, jenž by měl respektovat bezpečnost, svobodu a soukromí uživatelů, úspěšně skončila. Bylo vybráno více než 2,1 milionu dolarů, tj. cíl kampaně byl splněn na více než 141 %. Objednáno bylo cca 3 000 telefonů. Telefon Librem 5 by měl být k dispozici v lednu 2019.

Ladislav Hagara | Komentářů: 1
včera 21:11 | Komunita

Ke zhlédnutí jsou videozáznamy přednášek z konferencí All Systems Go! (media.ccc.de) a GStreamer Conference 2017 (ubicast.tv) konaných o víkendu 21. a 22. října. All Systems Go! v Berlíně a GStreamer Conference 2017 v Praze.

Ladislav Hagara | Komentářů: 0
včera 20:33 | Komunita

MojeFedora.cz informuje (en), že Fedora 27 přináší snadný přístup k Red Hat Enteprise Linuxu. Virtualizační nástroj Boxy nyní umožňuje jednoduše stáhnout a nainstalovat Red Hat Enterprise Linux, který je pro vývojáře zdarma. Vytvořit lze neomezené množství virtuálních mašin s RHEL.

Ladislav Hagara | Komentářů: 1
včera 19:00 | Komunita

Konsorcium Linux Foundation oficiálně představilo licence pro komunitní otevřená data Community Data License Agreement (CDLA). První licence je copyleftová CDLA-Sharing a druhá permisivní CDLA-Permissive. Odpovědi na často kladené otázky ve FAQ.

Ladislav Hagara | Komentářů: 0
včera 13:55 | Pozvánky

Spolek OpenAlt zve příznivce otevřených technologií a otevřeného přístupu na 145. pražský sraz, který proběhne ve čtvrtek 26. října od 18:00 hodin v karlínském Pivovarském klubu. Najdete jej kousek od metra Florenc na adrese Křižíkova 17, Praha 8. Jedná se o poslední sraz před konferencí OpenAlt 2017, jež proběhne o víkendu 4. a 5. listopadu 2017 na FIT VUT v Brně. Běží registrace účastníků.

Ladislav Hagara | Komentářů: 0
včera 06:00 | Zajímavý software

Byla vydána verze 0.56 open source platformy Home Assistant (GitHub) pro monitorování a řízení inteligentní domácnosti naprogramované v programovacím jazyce Python verze 3 a bežící také například na Raspberry Pi. Pro vyzkoušení je k dispozici demo [reddit].

Ladislav Hagara | Komentářů: 0
22.10. 16:55 | Nová verze

Byla vydána verze 1.0 klienta F-Droid určeného pro instalaci aplikací do Androidu ze softwarového repozitáře F-Droid (Wikipedie), alternativy k Google Play, nabízející pouze svobodný a otevřený software. Podrobnosti v přehledu změn [Hacker News].

Ladislav Hagara | Komentářů: 6
22.10. 00:55 | Nová verze

Po téměř 13 měsících vývoje od verze 0.11.0 byla vydána verze 0.12.0 hardwarově nenáročného desktopového prostředí LXQt (Lightweight Qt Desktop Environment, Wikipedie) vzniklého sloučením projektů Razor-qt a LXDE. Přehled novinek v příspěvku na blogu.

Ladislav Hagara | Komentářů: 10
21.10. 12:33 | Zajímavý software

Článek ne Medium představuje nejnovější stabilní verzi 2.0 svobodné decentralizované mikroblogovací platformy a sociální sítě podobné Twitteru Mastodon (Wikipedie). Detailní přehled novinek na GitHubu [Hacker News].

Ladislav Hagara | Komentářů: 0
21.10. 06:00 | Komunita

V Praze na půdě Elektrotechnické fakulty ČVUT dnes probíhá RT-Summit 2017 – setkání vývojářů linuxového jádra a uživatelů jeho real-time verze označované jako preempt-rt. Přednášky lze sledovat online na YouTube.

Ladislav Hagara | Komentářů: 0
Jak se vás potenciálně dotkne trend odstraňování analogového audio konektoru typu 3,5mm jack z „chytrých telefonů“?
 (10%)
 (1%)
 (0%)
 (1%)
 (75%)
 (12%)
Celkem 235 hlasů
 Komentářů: 8, poslední 22.10. 23:02
    Rozcestník

    Google Go – pravidla reflexe

    4. 10. 2011 | Jan Mercl | Programování | 4401×

    Na oficiálním blogu jazyka Go se objevil další zajímavý a užitečnými informacemi nabitý článek (Rob Pike: „The Laws of Reflection“), který je níže přeložen do češtiny. Informace o typech dostupné za běhu programu jsou v Go srovnatelné s tím, co poskytují některé jiné programovací jazyky, a podobně též umožňují typy nejenom prozkoumávat, ale, v rámci jistých omezení, také např. vytvářet jejich instance. Tohoto tématu jsme se v seriálu dosud nedotkli.

    Obsah

    Schopnost programu zkoumat svou vlastní strukturu, jmenovitě typy v programu deklarované, je formou metaprogramování a (nejenom) v Go se nazývá „reflection“ (reflexe). Reflection je také vděčným zdrojem zmatků a počátečních nepochopení.

    Pokusem o ujasnění práce s Go reflection je tento článek. Modely reflection jsou v každém programovacím jazyce trochu jiné (a spoustu z nich reflection nemá vůbec), nicméně tento článek je o Go, takže význam reflection následujícím textu je „reflection v Go“.

    Typy a rozhraní

    link

    Reflection je postaveno na systému typů, takže na začátek si zopakujme co o typech v Go už víme.

    Go je staticky typovaný jazyk. Jakákoli proměnná má svůj statický typ, tedy právě jeden typ, který je pevně určen při kompilaci: int, float32, *MyType, []byte apod. Pokud deklarujeme

    type MyInt int
    var i int
    var j MyInt

    Pak i má typ int a j typ MyInt. Statické typy i a j jsou rozdílné, nelze je vzájemně přiřazovat, přestože se shodují v typu, ze kterého jsou typy i a j odvozené.

    Důležitou kategorií typů jsou ty, které reprezentují pevnou množinu metod, tedy rozhraní. Hodnotou proměnné s typem rozhraní může být libovolná konkrétní hodnota (jiného typu, který sám není rozhraním), pokud tato hodnota implementuje všechny metody rozhraní (toho, který je typem oné proměnné). Dobře známým příkladem jsou rozhraní io.Reader a io.Writer, tedy typy Reader a Writer modulu io:

    // Reader je rozhraní deklarující základní metodu Read.
    type Reader interface {
        Read(p []byte) (n int, err os.Error)
    }
    
    // Writer je rozhraní deklarující základní metodu Write.
    type Writer interface {
        Write(p []byte) (n int, err os.Error)
    }

    Rozhraní io.Reader (nebo io.Writer) je implementováno každým typem, který implementuje metodu Read (nebo Write) s výše uvedeným podpisem (method signature). V rámci tohoto výkladu to znamená, že proměnná typu io.Reader může obsahovat libovolnou hodnotu, jejíž typ implementuje metodu Read:

    var r io.Reader
    r = os.Stdin
    r = bufio.NewReader(r)
    r = new(bytes.Buffer)
    // a tak dále
    

    Ať už bude r obsahovat jakoukoli hodnotu, je důležité aby bylo jasné, že typem r je vždy io.Reader: Go je staticky typovaný jazyk a statickým typem r je io.Reader.

    Prázdné rozhraní je typem rozhraní, které je mimořádně důležitým příkladem:

    interface{}

    Reprezentuje prázdnou množinu metod a protože jakýkoli typ má nulový nebo větší počet metod, je splněno libovolnou hodnotou.

    Často můžete od některých lidí slyšet, že Go rozhraní mají dynamický typ, to je však zavádějící. Mají statický typ a proměnná typu rozhraní má vždy stejný statický typ. A přestože se za běhu programu může hodnota proměnné typu rozhraní měnit tak bude vždy splňovat rozhraní, které je statickým typem dané proměnné.

    Bylo nutné si toto vše upřesnit, protože reflection a rozhraní jsou úzce propojeny.

    Struktura rozhraní

    link

    Vnitřní reprezentaci Go rozhraní popsal Russ Cox detailně ve svém blog postu. Nemusíme tady nutně celý článek opakovat, ale zjednodušený souhrn je potřebný.

    Proměnná typu rozhraní je dvojice: konkrétní hodnota přiřazená proměnné a deskriptor typu této hodnoty. Přesněji řečeno, hodnota jsou konkrétní data typu, který splňuje rozhraní a deskriptor určuje plně typ těchto dat. Například po

    var r io.Reader
    tty, err = os.OpenFile("/dev/tty", os.O_RDWR, 0)
    if err != nil { return nil, err }
    r = tty

    zjednodušeně obsahuje r dvojici (hodnota, typ), v tomto případě (tty, *os.File). Všimněte si, že *os.File implementuje i jiné metody než Read přestože hodnota (r, typu rozhraní io.Reader) zpřístupňuje pouze metodu Read. Hodnota r ale má všechny informace o svém (skutečném/dynamickém – pozn. př.) typu. Díky tomu můžeme napsat třeba:

    var w io.Writer
    w = r.(io.Writer)

    Výraz na pravé straně přiřazení je ověření typu (type assertion). Ověřujeme zde, že hodnota uložená v r (taktéž) implementuje rozhraní io.Writer a že ji tedy můžeme přiřadit do w. Výsledkem přiřazení je, že w bude obsahovat dvojici (tty, *os.File). To je ovšem stejná dvojice, která byla uložena v r. Statický typ rozhraní určuje které metody můžeme pro danou proměnou typu rozhraní volat a není důležité, že hodnota v proměnné uložená může mít množinu metod větší.

    Pokračujeme-li ve stejném duchu:

    var empty interface{}
    empty = w

    tak proměnná empty bude zase obsahovat tu samou dvojici (tty, *os.File). To se hodí: prázdnému rozhraní (proměnné takového typu) můžeme přiřadit hodnotu jakéhokoli typu, ta si sebou stále ponese veškeré informace, které o této hodnotě a jejím typu budeme kdy potřebovat.

    (Na tomto místě jsme nepotřebovali ověřit typ. To, že typ proměnné w splňuje prázdné rozhraní, je známo staticky. V předchozím případě, kdy jsme přiřazovali mezi proměnnou typu io.Reader a typu io.Writer, to bylo nutné vyjádřit explicitně, protože množina metod io.Writer není podmnožinou metod io.Reader)

    Podstatným detailem je, že dvojice uvnitř rozhraní má vždy tvar (hodnota, konkrétní typ) a nemůže mít formu (hodnota, rozhraní [interface type]). Do proměnné typu rozhraní nelze uložit hodnotu typu rozhraní.

    Nyní jsme připraveni si probrat reflection.

    První pravidlo: Pracujeme s daty rozhraní a přenášíme je do reflection objektu

    link

    Mechanismus reflection je na své základní úrovni pouhým zkoumáním dvojice (hodnota, typ) uložené v rozhraní. Na úvod potřebujeme znát dva typy modulu reflectType a Value. Tyto dva typy zpřístupňují obsah rozhraní. Dvě jednoduché funkce reflect.TypeOf a reflect.ValueOf vracejí reflect.Type a reflect.Value typované hodnoty, získané z proměnné typu rozhraní. (Navíc je možné z reflect.Value snadno získat i reflect.Type, ale ponechme koncepty Value a Type zatím oddělené.)

    Začněme s TypeOf:

    package main
    
    import (
            "fmt"
            "reflect"
    )
    
    func main() {
            var x float64 = 3.4
            fmt.Println("type:", reflect.TypeOf(x))
    }
    

    Tento program vypíše

    type: float64
    

    Možná se divíte – kde je tady nějaké rozhraní? Vypadá to přece tak, že program předává proměnnou x typu float64, nikoli hodnotu typu rozhraní funkci reflect.TypeOf. Ale rozhraní tam je. Jak vidno v dokumentaci, argumentem TypeOf je hodnota typu prázdného rozhraní.

    // TypeOf returns the reflection Type of the value in the interface{}.
    func TypeOf(i interface{}) Type
    

    Při volání reflect.TypeOf(x) je x nejrpve uloženo do prázdného rozhraní, které je pak předáno jako argument, reflect.TypeOf pak z tohoto prázdného rozhraní vrátí informaci o typu x.

    Funkce reflect.ValueOf pak pochopitelně vrací hodnotu (dále už vynecháváme opakující se kód a soustředíme se jen na důležitý kód)

    var x float64 = 3.4
    fmt.Println("value:", reflect.ValueOf(x))
    

    vypíše

    value: <float64 Value>
    

    Jak reflect.Type tak reflect.Value mají hodně metod, které nám umožňují je zkoumat a manipulovat s nimi. Jedním z důležitých příkladů je, že Value má metodu Type, která vrací Type dané reflect.Value. Dalším je, že Type i Value mají metodu Kind, která vrací konstantu, příznak jakého druhu je hodnota v nich uložená: Uint, Float64, Slice atd. Dále metody Value s názvy jako Int nebo Float vracejí uložené hodnoty (typu int64 resp. Float64):

    var x float64 = 3.4
    v := reflect.ValueOf(x)
    fmt.Println("type:", v.Type())
    fmt.Println("kind is float64:", v.Kind() == reflect.Float64)
    fmt.Println("value:", v.Float())
    

    vypíše

    type: float64
    kind is float64: true
    value: 3.4
    

    Existují také metody jako SetInt a SetFloat, ale bychom je mohli použít musíme nejprve pochopit koncept „měnitelnosti“ (settability), který je předmětem třetího pravidla, to ale přijde na řadu později.

    Některé vlastnosti modulu reflect stojí za poznámku. Za prvé, aby bylo API jednoduché, operují „getter“ a „setter“ metody Value na největším typu, do kterého je možné hodnotu uložit: např. int64 pro všechny celočíselné hodnoty se znaménkem. Takže metoda Int typu Value vrací int64 a argumentem metody SetInt je int64, je tedy možné, že bude třeba konverze na ten který typ se kterým skutečně pracujeme:

    var x uint8 = 'x'
    v := reflect.ValueOf(x)
    fmt.Println("type:", v.Type()) // uint8.
    fmt.Println("kind is uint8: ", v.Kind() == reflect.Uint8) // true.
    x = uint8(v.Uint()) // v.Uint returns a uint64.
    

    Další vlastností je, že Kind reflection objektu popisuje hodnotu obsaženou v proměnné typu rozhraní, nikoli statický typ onoho rozhraní. Pokud je tedy v reflection objektu uložena hodnota uživatelem definovaného typu jako v:

    type MyInt int
    var x MyInt = 7
    v := reflect.ValueOf(x)
    

    pak v.Kind bude stále vracet reflect.Int přestože statický typ x je MyInt, nikoli int. Jinak řečeno, Kind neumí rozlišit int a MyInt ačkoli Type to samozřejmě umí.

    Druhé pravidlo: Pracujeme s reflection objektem a přenášíme informace do proměnné typu rozhraní.

    link

    Anglické slovo „reflection“ lze přeložit jako odraz. Tak jako odraz ve fyzice má „odraz“ v Go svou vlastní inverzi.

    Máme-li reflect.Value, tak můžeme získat zpět hodnotu s typem rozhraní pomocí metody Interface, ve svém důsledku tato metoda znovu poskládá dvojici (hodnota, typ) do dříve popsané reprezentace rozhraní a tuto vrátí:

    // Interface vrátí hodnotu v jako interface{}.
    func (v Value) Interface() interface{}
    

    Můžeme tedy psát

    y := v.Interface().(float64) // y bude mít typ float64.
    fmt.Println(y)
    

    pro vypsání float64 hodnoty reprezentovanou reflection objektem v.

    Ale jde to i lépe. Argumenty fmt.Println, fmt.Printf apod. jsou předávány jako hodnoty prázdného rozhraní, které si potom modul fmt vnitřně rozbaluje přesně tak, jako jsme činili v předcházejících příkladech. Pro korektní vypsání hodnoty reflect.Value tedy stačí předat formátovacím funkcím výsledek metody Interface:

    fmt.Println(v.Interface())
    

    (Proč ne rovnou fmt.Println(v)? Kvůli tomu, že v je reflect.Value; chceme vypsat konkrétní hodnotu, která je ve v uložena.) Protože naše hodnota je typu float64, tak když budeme chtít, můžeme dokonce použít i formátování pro čísla v plovoucí čárce:

    fmt.Printf("value is %7.1e\n", v.Interface())
    

    a dostaneme v tomto případě

    3.4e+00
    

    Zopakujme, že není potřeba dělat ověření typu u výsledku v.Interface() na float64; hodnota typu prázdné rozhraní si s sebou specifickou informaci o obsaženém typu vždy nese a Printf si ji odtud získá.

    Stručně řečeno – metoda Interface je opakem funkce ValueOf, odlišnost je jen v tom, že její výsledek má vždy statický typ interface{}.

    Zopakujme: Cesta dat v reflection jde z hodnot typu rozhraní do reflection objektů a zase zpět

    Třetí pravidlo: Modifikovat reflection objekt lze jedině, je-li měnitelný

    link

    Třetí zákon je ze všeho nejvíc jen drobným upřesněním, současně je však i největším zdrojem zmatení. Nicméně jej snadno pochopíme, pokud začneme u prvotních principů.

    Tady je kód, který nebude fungovat, ale stojí za prostudování.

    var x float64 = 3.4
    v := reflect.ValueOf(x)
    v.SetFloat(7.1) // Chyba: vyvolá výjimku (panic).
    

    Pokud byste takový program spustili, uvidíte tajemnou hlášku

    panic: reflect.Value.SetFloat using unaddressable value
    

    Problém netkví v tom, že hodnota 7.1 není adresovatelná – potíž způsobuje, že v není měnitelné.

    Metoda CanSet typu Value nám řekne, je-li Value měnitelné; v našem případě,

    var x float64 = 3.4
    v := reflect.ValueOf(x)
    fmt.Println("settability of v:" , v.CanSet())
    

    vypíše

    settability of v: false
    

    Volání metody Set u hodnoty Value, která není měnitelná, je chyba. Co je ona „měnitelnost“?

    Je to téměř něco jako adresovatelnost, ale zpřísněná. Tato vlastnost říká, že reflection objekt smí přepisovat původní místo v paměti, které posloužilo k vytvoření reflection objektu. Měnitelnost je určena tím kterým reflection objektem, který „drží“ původní data. Když napíšeme

    var x float64 = 3.4
    v := reflect.ValueOf(x)
    

    pak předáváme reflect.ValueOf kopii x, tedy hodnota typu rozhraní předaná reflect.ValueOf nese kopii x a nikoli x samotné. Pokud by tedy příkazu

    v.SetFloat(7.1)
    

    bylo „dovoleno“ fungovat, tak by novou hodnotu nenastavil proměnné x, ačkoli se v tváří, jako by bylo z x vytvořeno. Místo toho by došlo k nastavení hodnoty kopie x uvnitř reflection objektu a samo x by zůstalo nezměněno. To by bylo nejen k ničemu, ale i překvapující; je to tedy zakázáno a koncept měnitelnosti je určen právě k tomu, aby tyto potíže nenastávaly.

    Zdá-li se vám to podivné, není tomu tak. Ve skutečnosti jde o známou situaci v novém hávu. Představte si předání x funkci:

    f(x)
    

    Neočekáváme, že f by mohla měnit x, protože jsme předali kopii hodnoty x, nikoli x samo. Pokud bychom od f chtěli měnit x, museli bychom naší funkci předat adresu x (čili ukazatel na x):

    f(&x)
    

    Toto považujeme za samozřejmost a známou věc; jenže reflection pracuje stejným způsobem. Jestliže chceme pomocí reflection x měnit, pak musíme reflection knihovně předat ukazatel na hodnotu, kterou chceme modifikovat:

    Zkusme to. Nejprve nastavíme x jako obvykle a pak vytvoříme reflection objekt, který ukazuje na x, nazvěme jej p.

    var x float64 = 3.4
    p := reflect.ValueOf(&x) // Pozn.: ukazatel na x.
    fmt.Println("type of p:", p.Type())
    fmt.Println("settability of p:" , p.CanSet())
    

    Zatím bude výstup

    type of p: *float64
    settability of p: false
    

    Reflection objekt p není měnitelný, ale není to p, které chceme měnit, tím je (v důsledku) *p. Pomocí metody Elem typu Value se dostaneme k tomu, na co odkazuje p, a výsledek uložíme do proměnné v typu reflection.Value:

    v := p.Elem()
    fmt.Println("settability of v:" , v.CanSet())
    

    Teď už je v měnitelný reflection objekt, jak vidíme z výpisu,

    settability of v: true
    

    a protože reprezentuje x, jsme konečně schopni použít v.SetFloat a změnit hodnotu x:

    v.SetFloat(7.1)
    fmt.Println(v.Interface())
    fmt.Println(x)
    

    Výstup je dle očekávání

    7.1
    7.1
    

    Reflection je možná obtížnější na pochopení, ale to co se děje je přesně totéž, jako běžně provádíme v Go. Jen je cesta nepřímá přes reflection objekty Type a Value, to může zastínit jak se věci odehrávají. Postačí si uvědomit, že reflection Value potřebuje ukazatel na něco, jedině pak je možné hodnotu, kterou Value reprezentuje, změnit.

    Struktury (Structs)

    link

    V našich předcházejících příkladech nebylo v samo o sobě ukazatelem, bylo z něj pouze vytvořeno. Běžně se do takové situace dostáváme, když používáme reflection pro změny polí struktur. Měnit pole struktury můžeme, jestliže máme ukazatel na strukturu.

    Tady je jednoduchý příklad, ve kterém prozkoumáváme hodnotu struktury t. Vytvoříme reflection objekt z ukazatele na strukturu, protože ji budeme chtít později měnit. Následně nastavíme typeOfT na typ struktury a budeme prostě procházet jednotlivá pole pomocí volání metod (podrobnosti v dokumentaci modulu reflect). Všimněte si, že získáváme jména polí z typu struktury, ale přístup k polím je přes normální reflect.Value objekty.

    type T struct {
        A int
        B string
    }
    t := T{23, "skidoo"}
    s := reflect.ValueOf(&t).Elem()
    typeOfT := s.Type()
    for i := 0; i < s.NumField(); i++ {
        f := s.Field(i)
        fmt.Printf("%d: %s %s = %v\n", i,
            typeOfT.Field(i).Name, f.Type(), f.Interface())
    }
    

    Výstupem tohoto programu je

    0: A int = 23
    1: B string = skidoo
    

    Tím se dostáváme ještě k jedné poznámce o měnitelnosti: názvy polí T začínají velkým písmenem (jsou exportovaná), protože pouze taková pole jsou pomocí reflection měnitelná.

    Díky tomu, že s je měnitelný reflection objekt, tak můžeme nastavovat hodnoty polí struktury.

    s.Field(0).SetInt(77)
    s.Field(1).SetString("Sunset Strip")
    fmt.Println("t is now", t)
    

    A tady je výsledek:

    t is now {77 Sunset Strip}
    

    Kdybychom program změnili tak, že s vytvoříme z t a nikoli &t, pak by volání SetInt a SetString selhala, protože pole t by nebyla měnitelná.

    Na závěr

    link

    Zopakujme pravidla reflection:

    1. Z hodnot typu rozhraní vytváříme reflection objekty.

    2. Z reflection objektů vytváříme hodnoty typu rozhraní.

    3. Nastavit hodnotu reprezentovanou reflection objektem můžeme jedině pokud je reflection objekt měnitelný.

    Jakmile pochopíte tato pravidla reflection v Go, bude jeho použití o hodně snazší, přestože některé detaily mohou stále překvapit. Reflection je mocný nástroj a jako všechny takové nástroje by mělo být používáno s rozmyslem, a to jen tam, kde je to nezbytně nutné.

    Kolem reflection je toho o hodně více, než jsme probrali — posílání a příjem u kanálů (channels), alokace paměti, používání řezů a map, volání metod a funkcí — jenže tento text je dlouhý už dost. K některým těmto tématům se vrátíme v pozdějším článku.

    (Originální text v angličtině: vizte odkazy v záhlaví této české verze. Licence pro šíření: Creative Commons Attribution 3.0 License)

    Laboratoře CZ.NIC

    O autorovi překladu

    Jan Mercl, autor překladu, pracuje v Laboratořích CZ.NIC jako programátor pro výzkum a vývoj.

           

    Hodnocení: 100 %

            špatnédobré        

    Nástroje: Tisk bez diskuse

    Tiskni Sdílej: Linkuj Jaggni to Vybrali.sme.sk Google Del.icio.us Facebook

    Komentáře

    Vložit další komentář

    4.10.2011 11:13 loki
    Rozbalit Rozbalit vše Re: Google Go – pravidla reflexe
    Hergot, to je clanek jak ma byt. Dekuji za nej a jen tak dal. :-)
    Saljack avatar 4.10.2011 18:01 Saljack | skóre: 28 | blog: Saljack | Praha
    Rozbalit Rozbalit vše Re: Google Go – pravidla reflexe
    Už někdo Go používá? Existuje nějaké projekty napsané v Go?
    Sex, Drugs & Rock´n Roll.
    4.10.2011 18:22 jnml
    Rozbalit Rozbalit vše Re: Google Go – pravidla reflexe
    Google používá Go interně, ale neuvádí podrobnosti kde a jak moc. V CZ.NICu se Go používá už rok. Pár dalších příkladů firem používajících Go (pravděpodobně dosti neúplný seznam).

    Rozličné projekty v Go např. tady nebo zde.
    5.10.2011 15:18 lertimir | skóre: 60 | blog: Par_slov
    Rozbalit Rozbalit vše Re: Google Go – pravidla reflexe
    Hmmm. Původně jsem vstoupil na tento článek s nadějí, že by se Google věnoval nádherné japonské hře Go. :-) Bohužel realita je daleko prozaičtější. :-(
    5.10.2011 22:06 adssa
    Rozbalit Rozbalit vše Re: Google Go – pravidla reflexe
    stale osklivejsi a osklivejsi jazyk :D
    6.10.2011 09:55 brekeke
    Rozbalit Rozbalit vše Re: Google Go – pravidla reflexe
    Aj mne sa zda, ono, ja mam taku teoriu, ze mozog moze zvladnut len urcitu mieru zlozitosti. Inak mu to uz proste prerastie cez hlavu a sam sa v tom zamotava. Myslim, ze Go je jeden taky priklad. Aj ked sa snazia spravit to jednoduchsie, co sa mi teda nezda. Samozrejme je nespochybnitelne, ze naroky na programovacie jazyky sa zvysuju, ale snazme sa to robit uplne sprosto aj za cenu nizsej efektivity a "performance". Programovanie v takychto jazykoch zostane zdrojom obzivy len aziatom :)

    Založit nové vláknoNahoru

    ISSN 1214-1267   www.czech-server.cz
    © 1999-2015 Nitemedia s. r. o. Všechna práva vyhrazena.