Go (програмски језик)

Гоу
Маскота језика је амерички глодар рупар (енгл. gopher), а аутор је Рене Френч.
Оригинални назив	енгл. Go
Изговара се	гоу
Модел	императивни, конкурентни
Појавио се	10. новембар 2009. (2009-11-10)
Аутор(и)	Google Inc., доприносиоци из заједнице отвореног кода
Дизајнер(и)	Роберт Грисемер Роб Пајк Кен Томпсон
Актуелна верзија	1.6
Датум актуелне верзије	17. фебруар 2016. (2016-02-17)
Систем типова	статички, номинални, структурни
Имплементације	gc (главна имплементација), gccgo (у оквиру ГНУ колекције компилатора), gopherjs (преводи Гоу програме у JavaScript)
Утицаји	Alef, APL, C, CSP, Limbo, Modula-2, Newsqueak, Oberon, Паскал, Пајтон, Smalltalk
Оперативни системи	Линукс, Mac OS X, Мајкрософт виндоус, OpenBSD, FreeBSD, NetBSD, Plan 9, Solaris
Лиценца	Модификована BSD лиценца + патент
Веб-сајт	http://golang.org/
Документација	http://golang.org/doc/

Гоу (енгл. Go) је програмски језик отвореног кода настао у Гуглу 2007. године. Језик су осмислили Роберт Грисемер, Роб Пајк и Кен Томпсон, а намењен је првенствено системском програмирању. Ослањајући се на традицију језика C и Паскал, језик је компилиран, са статичким типовима података, ограниченим структурним типовима, садржи аутоматско управљање меморијом и функционалности за конкурентно програмирање инспирисане комуницирајућим секвенцијалним процесима.

Почетак рада на језику је септембар 2007. године. Званично је промовисан новембра 2009. године под модификованом BSD лиценцом. Данас се користи за мрежне програме, најпре у оквиру Гуглових система, али и у другим компанијама. Постоје две главне имплементације језика: gc, који је главна имплементација коју је развио Гугл и gccgo из ГНУ колекције компајлера. До верзије 1.5, gc имплементација је била написана у мешавини C, асемблер и Гоу кода, а од верзије 1.5, C код је преведен у Гоу.

Историја

Језик је настао као експеримент тројице Гуглових запослених—Роберт Грисемер, Роб Пајк и Кен Томпсон. Идеја је била да се дизајнира нови језик за системско програмирање који би решио главне проблеме постојећих језика у тој групи а притом задржао њихове позитивне особине. Нови језик би имао следеће особине:

• био би статички компилиран и могао би да се се користи за велике системе (као Java и C++),
• програмирање би било продуктивно а програми читљиви, без превише обавезних кључних речи и понављања (као код динамичких језика),
• не би захтевао компликоване алате, већ би их добро подржао
• подржавао би програмирање у мрежи и вишеструко процесирање

У интервјуима, сва тројица дизајнера су изразила да нису љубитељи сложености C++-а, и да је то била главна мотивација за дизајнирање новог језика.

Дизајн језика

Највећи утицај на дизајн језика су језици из породице C и Паскал. Они се од ових језика разликују по додацима који побољшавају концизност, једноставност и безбедност програма.

Кратак преглед особина које карактеришу Гоу:

• Синтакса и окружење које прихвата идеје које се чешће срећу у динамичким језицима.
  • Опциона скраћена декларација и иницијализација променљивих кроз локално закључивање типова података (енгл. local type inference; i := 0 уместо int i = 0;).
  • Брза компилација програма у извршну датотеку.
  • Једноставно управљање пакетима (go get), као и једноставна и читљива документација пакета на интернету.
• Јединствени приступи проблемима:
  • Уграђене функционалности за конкурентно програмирање: лаки процеси (корутине - goroutines), канали за ток података између процеса, и select кључна реч за управљање каналима.
  • Систем интерфејса и уграђивања типова уместо уместо виртуалног и невиртуалног наслеђивања.
  • Скуп алата који производи статички линковане извршне датотеке које не зависе од спољашњих библиотека.
• Тежња ка једноставности језика - спецификација је довољно кратка да програмери могу целу да је запамте. Ово је могуће захваљујући избацивању функционалности које се често срећу у другим језицима.
• Изворне датотеке са кодом су увек кодиране као UTF-8, што омогућује локализовање коментара и документације, али и имена типова, функција, променљивих и константи.

Гоу је често мета следећих критика:

• Недостатак генеричких типова доводи до дупликације кода. Може се симулирати уз помоћ метапрограмирања и рефлексије, али се тада губи на перформансама и провери тачности типова. Стандардна библиотека из тог разлога не нуди генеричке алгоритме.
• Нема могућности проширивања језика (на пример, кроз додавање оператора за корисничке типове), па одређени задаци захтевају више кода.
• Једноставан систем типова који није базиран на Хиндли-Милнер систему смањује безбедност и једноставност програма.
• Аутоматско управљање меморијом узрокује паузе у раду програма, па то умањује могућност примене у системским програмима, у поређењу са језицима у којима се ручно управља меморијом.

Дизајнери језика тврде да су ови недостаци важни за успех језика, и детаљно објашњавају зашто су одређене одлуке донешене. Упркос томе, отворени су за додавање могућности за генеричко програмирање у будућности, као и по питању побољшања у областима генерације кода и смањења трајања паузе приликом аутоматског чишћења меморије.

Синтакса

Синтакса је најсличнија језицима из C породице језика, али је знатно измењена како би програми били концизнији и читљивији, као и да би подржала нове додатке језику.

Постоји комбиновани оператор за декларацију и иницијализацију променљивих; уз помоћ овог оператора могуће је написати i := 3 или s := "tekst" без прецизирања типова података. Ово је супротно од декларације и иницијализације у C-у: int i = 3; и const char * s = "tekst";.

Искази се завршавају са симболом тачка-зарез, али се он не мора наћи у изворном коду на местима где се завршава ред. Алат go fmt из основне дистрибуције избацује овај симбол са места на којима је сувишан.

Функције могу враћати више вредности, па је шаблон враћања пара result, error главни метод индикације постојања грешке настале током позива дате функције. Сличан шаблон се примењује за приступ мапама и за локално проверавање типа податка, са тим што је тада пар који се враћа result, bool, где други параметар указује на тачност операције.

Гоу такође додаје синтаксу за иницијализацију параметара у struct типу по имену, као и за иницијализацију мапа и низова.

Као замену за C-ове for, while и do/while петље, Гоу уводи комбиновану for петљу која заједно са range изразом омогућује једноставну итерацију низова, одсечака, мапа, канала, и ниски.

Типови података

Гоу има одређен број уграђених типова података, укључујући Булов тип података, нумеричке типове (byte, rune, int, float, complex), и ниске. Ниске су непроменљиве, а помоћу уграђених оператора и кључних речи могуће је спајање, поређење и кодирање из и у UTF-8. Сложени типови (енгл. record type) се могу дефинисати уз помоћ кључне речи struct.

Типом податка T и бројем елемената n се дефинише низ означен са [n]T; пошто је број елемената део типа податка, низови којима су типови елемената исти али им је број елемената различит, су различитог типа.

Динамички низови се зову одсечци енгл. slice; за тип податка T, одсечак се означава са []T. Ови низови имају дужину и капацитет којим се означава када треба заузети нови део меморије за проширење одсечка. Неколико одсечака може да дели одређени меморијски простор.

За пар типова података K, V, тип map[K]V означава тип мапе (хеш табела) која мапира кључеве типа K на вредности типа V. Хеш табеле су уграђене у језик, имају посебну синтаксу, и над њима се операције врше уграђеним функцијама.

Канали (енгл. channel) за комуникацију између конкурентских процеса такође имају своју синтаксу. За тип податка T, тип канала се означава са chan T. Језик поседује и скуп уграђених операција којима се вредности могу примати и слати преко канала.

Показивачи постоје за све типове података; за тип податка T, показивач се означава са *T. За разлику од C-а, нема показивачке аритметике, осим кроз тип Pointer из пакета unsafe у стандардној библиотеци.

Поред подршке за интерфејсе, систем типова је номиналан (тј. заснива се на експлицитном именовању типова података). Кључна реч type ствара нови тип податка, који се разликује од осталих типова података који могу имати исти распоред у меморији (а у случају struct типа, и исти редослед поља). Неке конверзије између типова су уграђене, а додавање новог типа се могу дефинисати додатне конверзије. Конверзије између типова су увек експлицитне.

На пример, помоћу кључне речи type се може дефинисати тип за IPv4 адресе, које су 32-битни цели бројеви без предзнака:

type ipv4addr uint32

Са овом дефиницијом типа ipv4addr(x) интерпретира uint32 вредност у ИП адресу. Просто додељивање вредности x променљивој чији је тип ipv4addr није могуће јер, иако имају исту структуру у меморији, нису исти типови.

Константни изрази могу имати или немати типове; ако немају тип податка, он им се додељује када се њихова вредност додели некој променљивој, под условом да је конверзија могућа током компилације.

Функције такође имају типове. Могу да прихватају ниједан или више аргумената и да врате ниједну или више вредности; све ове вредности имају своје типове, а заједно они одређују потпис, односно тип функције. На пример, func(string, int32) (bool, error) је тип функције која као аргументе прима текст и 32-битни број са предзнаком (редом, string и int32), а враћа бул и грешку (редом, bool и error).

Сваки именовани тип може имати сет метода који је са њим повезан. Претходни пример се може проширити тако да има методе којим се врши штампање у читљивом формату, проверава да ли се налази у одређеном опсегу и слично, зависно од функционалности коју тип треба да има. Типу се метода додаје тако што се између кључне речи func и имена функције дода прималац (енгл. receiver), који се састоји од имена које представља референцу (слично речима this и self у језицима као што су Јава и Пајтон) и типа на који се метода односи.

// Is this the zero broadcast address 255.255.255.255?
func (addr ipv4addr) ZeroBroadcast() bool {
    return addr == 0xFFFFFFFF
}

Због номиналног система типова, ова метода је додата типу ipv4addr, али не и типу uint32.

Иако за њихово дефинисање и позивање постоји посебна синтакса, методе немају засебан тип. Сама синтакса је заправо "синтаксни шећер" (енгл. syntactic sugar), па ако је x променљива којој је додељена вредност чији је тип горепоменути ipv4addr, следеће две линије имају исто значење:

x.ZeroBroadcast()
ZeroBroadcast(x)

Интерфејси

Гоу поседује две особине којима замењује систем наслеђивања из класичног објектно-оријентисаног програмирања. Прво је уграђивање, које представља форму композиције или делегације. Други део су интерфејси, који омогућују полиморфизам у току извршавања програма.

Протоколи омогућују ограничен облик структурних типова података у оквиру номиналног система типова података. Сваки тип података над којим су дефинисане све методе из интерфејса имплицитно задовољава тај интерфејс. Сам систем интерфејса заснован је на систему протокола из језика Smalltalk. Интерфејс групише типове података у скуп, тако што сам представља листу метода које ти типови морају садрже. Типови који задовољавају одређени интерфејс не морају експлицитно то да нагласе, већ се та провера врши током компилације програма.

Типови Квадрат и Круг се могу груписати помоћу интерфејса Облик који од својих типова захтева да садрже методе Обим и Површина.

import "math"

type Облик interface {
    Обим() float64
    Површина() float64
}

type Квадрат struct {
    страница float64
}
func (кв Квадрат) Обим() float64 {
    return 4 * кв.страница
}
func (кв Квадрат) Површина() float64 {
    return кв.страница * кв.страница
}

type Круг struct {
    полупречник float64
}
func (к Круг) Обим() float64 {
    return math.Pi * к.полупречник * 2
}
func (к Круг) Површина() float64 {
    return math.Pi * math.Pow(к.полупречник, 2)
}

Сада се може дефинисати функција СабериПовршине која тражи два аргумента који задовољавају интерфејс Облик и сабира њихове површине:

func СабериПовршине(о1, о2 Облик) float64 {
    return о1.Површина() + о2.Површина()
}

СабериПовршине(Круг{4}, Квадрат{2.7})

Пошто је задовољење интерфејса имплицитно, додавање нових типова (нпр. Троугао или Трапез) се своди на дефинисање структуре типа и имплементације одређених метода, а то се може извршити и у оквиру другог пакета.

Стандардна библиотека језика користи интерфејсе у оквиру неколико библиотека. Један од примера је Stringer интерфејс из пакета fmt, који захтева методу String() string; задовољењем овог интерфејса, сваки тип може да одреди како ће његова вредност изгледати приликом штампе. Други пример су интерфејси Reader и Writer, којима се дефинише протокол за улаз и излаз података помоћу метода Read и Write, а користи код пакета за рад са датотекама, мрежним сокетима, стандардним улазом и излазом, баферима бајтова, токовима, , и слично.

Празан интерфејс (interface{}) представља важан случај у оквиру система типова, јер се односи на било који тип податка. Сличан је типу Object у језицима Јава и C#; разликује се од њих по томе што је то интерфејс који задовољавају сви типови укључујући и уграђене као што је int, док Object може држати само инстанце објеката јер представља надтип (енгл. supertype). Податак који је сачуван под типом interface{} се не може користити као аргумент при позиву функција или са уграђеним операторима без конверзије у конкретан тип помоћу наговештавања типа (енгл. type assertion), гранања по типу (енгл. type switch), или испитивањем рефлексијом уз помоћ reflect пакета. Зато што може да држи било који тип податка, interface{} представља један од начина за имплементацију генеричких алгоритама.

Систем пакета

Сваки пакет је дефинисан са два податка: својом путањом (нпр. "compress/bzip2" или "golang.org/x/net/html") и својим именом (нпр. bzip2 или html). Путања пакета је ниска, па може имати било какав садржај; пакети које корисници објављују на интернету садрже адресу са које пакет може бити преузет, чиме је олакшано управљање пакетима. Позив на други пакет увек садржи и име тог пакета, а да би нека вредност из пакета била видљива, њено мора почињати великим словом (нпр. функција Printf из пакета fmt је видљива у свим другим пакетима који позивају тај пакет, док је функција printf видљива само у оквиру fmt пакета).

Конкурентно програмирање

Језик поседује уграђене функционалности, као и скуп библиотека, који помажу писање конкурентних програма. Овде се конкурентност не односи само на паралелно извршавање програма, већ и на асинхронију: пуштање спорих операција као што је читање података са мреже или из базе података док програм извршава друге послове.

Главна структура за формирање конкурентних процеса је горутина (енгл. goroutine, игра речи са корутина), која представља лаган процес. Када се приликом позива функције испред имена функције нађе кључна реч go, та функција се позива у оквиру нове горутине. Спецификација језика не садржи начин имплементације горутина, а трентутне имплементације користе нити, слично као код језика Ерланг).

Иако стандардна библиотека садржи пакете са класичним структурама за контролу конкурентних процеса, идиоматски начин контроле укључује канале (енгл. channels), који омогућавају размену вредности између горутина. Канали имају своје типове података, па се канал типа chan T може користити само за слање вредности типа T. Операције над каналима користе посебну синтаксу; <-ch је израз који блокира тренутну горутину док не стигне вредност са канала ch, док ch <- x шаље вредност x преко канала ch (при чему може доћи до блокирања док друга горутина не прими ту вредност). Уграђена структура за гранање select (слична структури switch) омогућује имплементирање комуникације без блокирања преко више канала. Гоу има модел меморије који описује начин употребе канала и горутина за безбедно дељење меморије.

Тиме што поседује канале, Гоу се разликује од језика који користе модел учесника (енгл. actor model) као што је Ерланг, где се поруке шаљу директно учесницима (који одговарају горутинама). Модел учесника се може симулирати при чему се уводи коресподенција између горутина и канала, иако језик дозвољава да више горутина дели један канал, или да једна горутина прихвата и шаље вредности на више канала.

Структурна правила за конкурентност су изведене из Тони Хоровог модела комуницирајућих секвенцијалних процеса. За разлику од претходних језика који користе овај модел, као што су occam и Лимбо, Гоу не поседује механизме за безбедну и провериву конкурентност. Све горутине деле адресни простор, па се променљиви објекти и показивачи могу делити између горутина.

Изостављене особине

Гоу намерно изоставља одређене особине присутне у другим језицима, укључујући наслеђивање, генеричко програмирање, асертивност, аритметику са показивачима, и имплицитне конверзије између типова. Од ових особина, аутори језика су изразили отвореност ка додавању могућности за генеричко програмирање, а бранили су одлуке против додавања осталих особина. Уместо наслеђивања, препоручују коришћење интерфејса за динамичко позивање и композицију типова за поновно коришћење кода.

Што се тиче генеричког програмирања, неке од уграђених функција јесу генеричке (нпр. make/new, append), али се третирају као посебни случајеви; Роб Пајк сматра да је ово слабост језика и да постоји могућност промене. Тим који у оквиру Гугла развија језик је у једном тренутку направио компилатор за експериментални дијалекат језика који има генеричке типове, али га нису пустили у јавност.

Након што су испрва изузеци изостављени из језика, додат је panic/recover механизам, који се користи за грешке од којих систем не може да се опорави и које заустављају цео програм, или као пречицу за пропагирање грешака у оквиру пакета (не и између пакета; тада се користи пар result, error који је стандардан начин сигнализирања грешке).

Правила и стил

• Форматирање програма, укључујући индентацију, размаке, положаје заграда и други детаљи визуелног дела кода су стандардизовани уз помоћ алатке gofmt; програм golint врши додатне стилске провере кода.
• Алати и пакети из стандардне библиотеке сугеришу стандардан начин приступа различитим проблеимима као што су документација (godoc), тестирање (go test), компилација програма (go build),управљање пакетима (go get) итд.
• Компилатор уводи стриктно поштовање правила која у другим језицима постоје само у облику препорука. Неки од примера укључују забрану кружних зависности (два пакета не могу зависити један од другог), забрану неискориштених пакета и променљивих, и недостатак имплицитних конверзија типова.
• Изостављање неких од особина, као што је map функција из функционалних језика и try/catch/finally структура из објектних језика захтева стил програмирања који је експлцитан, конкретан и императиван.

Алати

Стандардна Гоу дистрибуција садржи следеће алате:

• go build, који компилира изворни код у извршне датотеке
• go run, који покреће програм без компилације, као скрипту
• go test, који покреће систем за тестирање и мерење перформанси програма
• go fmt, који форматира датотеке са изворним кодом сходно договореним правилима
• go get, који служи за управљање спољашњим пакетима помоћу различитих система контроле верзија
• go vet, који проналази грешке помоћу статичке анализе програма
• godoc, који приказује документацију пакета у командној линији или веб читачу
• gorename, који служи за безбедно преименовање типова, функција и променљивих
• go generate, који служи за покретање генеришућих програма као што је Yacc

Поред ових алата, корисници су допринели пишући своје програме који допуњују овај скуп алата. Неки од примера су goimports који проверава које пакете програм користи или не користи, па их додаје или брише са списка, gocode, који у оквиру различитих уређивача текста нуди информације о доступним типовима и функцијама, и golint, који указује на честе грешке у програмима и на недостатак документације.

Писање пакета је знатно олакшано постојањем go пакета у стандардној библиотеци, који нуди различите механизме за управљање и анализу датотека са изворним кодом.

Примери

Здраво свете

Следећи Гоу програм исписује „Здраво свете!":

package main

import "fmt"

func main() {
    fmt.Println("Здраво свете!")
}

Конкурентан пример

Следећи програм показује употребу конкурентних особина за писање асинхроних програма. Програм покреће две горутне: једна чека да корисник упише неки текст, а друга шаље сигнал након пет секунди. select гранање чека да било која од горутина достави поруку функцији main, и извршава се зависно од прве вредности која је стигла (пример адаптиран из књиге Давида Чизнала).

package main

import (
    "fmt"
    "time"
)

func readword(ch chan string) {
    fmt.Println("Упиши реч и притисни Enter.")
    var word string
    fmt.Scanf("%s", &word)
    ch <- word
}

func timeout(t chan bool) {
    time.Sleep(5 * time.Second)
    t <- true
}

func main() {
    t := make(chan bool)
    go timeout(t)

    ch := make(chan string)
    go readword(ch)

    select {
    case word := <-ch:
        fmt.Println("Примио", word)
    case <-t:
        fmt.Println("Истекло време.")
    }
}

Литература

• Chisnall, David (2012). The Go Programming Language Phrasebook. Addison-Wesley. ISBN 978-0-13-291900-5. 

Спољашње везе

• Званични веб-сајт
• Незванични извори за Гоу језик