01-intro.slide

Въведение в Go
10.10.2018

https://play.golang.org/

fmi@golang.bg
http://fmi.golang.bg/
@fmi_golang

* Малко история

.image assets/creators.jpg


* Малко история

- *2007* - ражда се идеята
- *2008* - стартира имплементирането на компилатора
- *2009* - първи публичен релийз
- *2010* - обявен за език на годината
- *2011* - използва се в production среда от Google
- *2012* - релийзната е 1.0
- *2013* - релийзнати са 1.1 и 1.2
- *2014* - релийзнати са 1.3 и 1.4
- *2015* - релийзната е 1.5
- *2016* - релийзнати са 1.6 и 1.7
- *2017* - релийзнати са 1.8 и 1.9
- *2018* - релийзнати са 1.10 и 1.11


* C for the 21st century*

- C е на *46*години*
- *Хардуерът* се променя
- *Проблемите*, които решаваме, също

* "Трите свята"

- C/C++: Бързо изпълнение за сметка на бавна разработка, бавна компилация и не особено тривиален контрол над зависимостите
- Java/C#: По-ефективен процес на разработка, компилация и контрол над зависимостите, за сметка на изпълнение и deployment
- JavaScript/Python/Ruby: Изключително ефективен процес на разработка, без стъпка на компилация, но изключително бавно изпълнение

- *: Трудна паралелизация и ефективност в мултипроцесорни системи

- Safety?
- Паралелизация и ефективност в мултипроцесорни системи?
- Error detection - runtime vs. compile-time?

* Резултатът

- Език с отворен код от сравнително ниско ниво (между C/C++ и Java/.NET)
- C-подобен синтаксис
- Дълбоко залегнала идея за конкурентност
- Вграден, бърз и ефективен garbage collector
- Безумно бърза компилация до машинен код
- Минимален runtime, single statically-linked native executable
- Cross-platform: Linux, OS X, Windows, BSD-та и Unix-и, mainframes и мобилни устройства
- Създаден да scale-ва
- Изключително опростен
- Safe by default, но `unsafe` при необходимост
- UTF-8 by default


* Други предимства?

- Много динамично развиващ се език
- Rock solid въпреки това - от доста време се използва в production от Google, Cloudflare, Soundcloud и [[https://github.com/golang/go/wiki/GoUsers][доста други компании]]
- Богата стандартна библиотека
- Вградени инструменти за unit и benchmark тестове
- Race condition detector
- Документация като feature
- Екосистема от удобни инструменти и сайтове
- Единна конвенция за писане на код
- Интеграция със C (макар и леко гадна)
- Модерен package management
- `go`get`-u`golang.org/x/tools/cmd/present`

* Екосистема от добри open-source библиотеки и проекти

- Docker, rkt, etcd, fleet, deis, consul, terraform, kubernetes и сума ти контейнерни библиотеки и приложения
- tidb, CockroachDB, InfluxDB, BoltDB, vitess
- Grafana, ngrok, Gogs и [[https://github.com/avelino/awesome-go][много други проекти]]


* Стандартната библиотека

archive tar zip bufio builtin bytes compress bzip2 flate gzip lzw zlib
container heap list ring context crypto aes cipher des dsa ecdsa elliptic hmac
md5 rand rc4 rsa sha1 sha256 sha512 subtle tls x509 pkix database sql driver
debug dwarf elf gosym macho pe plan9obj encoding ascii85 asn1 base32 base64
binary csv gob hex json pem xml errors expvar flag fmt go ast build constant
doc format importer parser printer scanner token types hash adler32 crc32 crc64
fnv html template image color palette draw gif jpeg png index suffixarray io
ioutil log syslog math big bits cmplx rand mime multipart quotedprintable net
http cgi cookiejar fcgi httptest httptrace httputil pprof mail rpc jsonrpc smtp
textproto url os exec signal user path filepath plugin reflect regexp syntax
runtime cgo debug msan pprof race trace sort strconv strings sync atomic
syscall js testing iotest quick text scanner tabwriter template parse time
unicode utf16 utf8 unsafe

* Научените уроци


* Малко код

    package workq

    type Queue []*Item

    func (q *Queue) Push(item *Item) {
        *q = append(*q, item)
        go item.Translate()
    }

    func (q *Queue) Pop() *Item {
        if !q.IsEmpty() {
            old := *q
            item := old[0]
            <- item.Done
            *q = old[1:len(old)]
            return item
        }
        return nil
    }

    func (q *Queue) Len() int {
        return len(*q)
    }

* Инсталация

*** Linux, FreeBSD

Инсталирате си пакета `go` от вашия пакетен мениджър

*** Mac OSX

.link https://golang.org/dl/ Използвате симпатичния инсталатор

*** Windows

.link https://golang.org/dl/ Използвате симпатичния инсталатор

По време на курса ще използваме версия 1.11.1


* Инсталация, епизод 2

1. Създавате директория `~/go`
2. Слагате следните два реда в `~/.profile`

    export GOPATH=$HOME/go
    export PATH=$PATH:$GOPATH/bin

*** За Windows-аджийте има уловки:

- Инсталаторът е избрал `C:\Go` вместо вас и можете да ползвате нея
- Операционната ви система е дошла с инсталиран PowerShell
- Запознайте се с него и се научете да го ползвате.


* Hello, world!

За да сме сигурни, че сме направили всичко като хората, създаваме файл hello.go:

.play code/intro/hello_world.go

и изпълняваме

    go run hello.go

* Как да пишем код на Go?

Имаме инструментът `go`, който се грижи за достатъчно много неща.
Повечето настройки се правят с `environment`variables`.


Имаме `workspace` папка с три основни директории:

- `src` съдържа нашия сорс код, който е организиран в пакети (за тях след малко)
- `pkg` съдържа т.нар. `package`objects`
- `bin` съдържа компилираните ни програми


* $ go

    build       compile packages and dependencies
    clean       remove object files and cached files
    doc         show documentation for package or symbol
    env         print Go environment information
    bug         start a bug report
    fix         update packages to use new APIs
    fmt         gofmt (reformat) package sources
    generate    generate Go files by processing source
    get         download and install packages and dependencies
    install     compile and install packages and dependencies
    list        list packages
    run         compile and run Go program
    test        test packages
    tool        run specified go tool
    version     print Go version
    vet         report likely mistakes in packages

.link http://golang.org/cmd/go/


* Environment variables

    $ go env
    GOARCH="amd64"
    GOBIN=""
    GOEXE=""
    GOHOSTARCH="amd64"
    GOHOSTOS="linux"
    GOOS="linux"
    GOPATH="/home/user/go"
    GORACE=""
    GOROOT="/usr/lib/go"
    GOTOOLDIR="/usr/lib/go/pkg/tool/linux_amd64"
    CC="gcc"
    GOGCCFLAGS="-fPIC -m64 -pthread -fmessage-length=0"
    CXX="g++"
    CGO_ENABLED="1"


* workspace

    bin/
        hello                          # command executable
        outyet                         # command executable
    pkg/
        linux_amd64/
            github.com/golang/example/
                stringutil.a           # package object
    src/
        github.com/golang/example/
            .git/                      # Git repository metadata
            hello/
                hello.go               # command source
            outyet/
                main.go                # command source
                main_test.go           # test source
        golang.org/x/image/
            .git/                      # Git repository metadata
            bmp/
                reader.go              # package source
                writer.go              # package source
        ... (many more repositories and packages omitted) ...

.link http://golang.org/doc/code.html#Workspaces


* Браво. И сега какво?

Връщаме се обратно към _Hello,_world!_ примера:

.code code/intro/hello_world.go

и се фокусираме върху

    package main


* Пакети

Една програма на `Go` е структура от пакети. Нямате шанс просто да хвърлите
едно парче код в даден файл и то да тръгне.

- Ако идвате от Python си мислете за модули.
- Ако идвате от Java се чувствайте като у дома си


* Особености

- Всеки файл принадлежи на точно един пакет
- `n` файла могат да са в един пакет (демек `filename` != `package`)
- Стандартната библиотека е съставена от пакети като `fmt`, `os`...
- Всяка директория съдържа точно един пакет
- Очевидно, дадени пакети могат да използват други

Без значение от колко файла се състои:

- всеки пакет се компилира като една самостоятелна единица
- всичко, дефинирано в пакета, има видимимост във всички негови файлове


* One package to rule them all

Ако си мислите за "Lord of the rings", грешите. Говорим ви за `main`.

В една програма имаме точно един пакет `main` и при изпълнението ѝ се изпълнява функцията `main` в него.

Програмата приключва, когато приключи изпълнението на функцията `main`.

Тя *не* връща нищо.


* Преизползване на пакети

Става с ключовата думичка `import`, последвана от името на пакета, в кавички

    import "fmt"

Ако искаме да импортнем няколко пакета:

    import "fmt"
    import "os"

което go fmt би свел до

    import (
        "fmt"
        "os"
    )

имаме и такива магии:

    import "github.com/keltia/leftpad"

_wow!_much_import!_how_to_dependency?_

* import

- По време на компилация се компилират първо импортнатите пакети
- Всеки пакет се компилира *точно* един път
- Ако един пакет се промени и прекомпилира, всички пакети, които го импортват, трябва да бъдат прекомпилирани
- Импортнат пакет, който не се използва, води до грешка по време на компилация

.play code/intro/hello_world_with_useless_import.go


* Видимост

Какво точно можем да използваме от импортнат пакет? Тук става забавно.

_Даден_идентификатор_(било_то_на_променлива,_константа,_тип,_функция_или_
_метод)_е_видим_извън_пакета_си,_тогава_и_само_тогава_когато_името_му_започва_с_главна_буква._

Наричаме ги `exported` (на други места им викат `public`).

Останалите са недостъпни (демек `private`)

* Основни типове
- bool
- uint, int
- float32, float64
- complex64, complex128
- string
- array
- struct
- channel


* ... но това не е всичко

* Независещи от архитектурата числови типове

Имаме свободата да решим точно колко байта да е нашия тип:

- int8
- int16
- int32 (познат също като rune)
- int64

\... и разбира се имаме `unsigned`:

- uint8 (познат също като byte)
- uint16
- uint32
- uint64

* Зависещи от архитектурата

- `uint` и `int` може да са 32 или 64 бита
- `uintptr` - нещо достатъчно голямо за да съдържа битовете на указател

*Пояснение*: типовете `int` и `int32` са различни дори в архитектури на които `int` е 32 бита. Същото важи и за `uint` и `uint32`.


* Пример

    var name string = "Лили Иванова"
    var age uint8 = 25

Горното можем (и трябва) да запишем като:

    var (
        name string = "Лили Иванова"
        age uint8 = 25
    )

Ако са с един и същи тип, можем и така:

     var name, age string = "Лили Иванова", "двадесет и пет"

_WTF!_WTF!_WTF!_ Защо типът е на грешното място!?

* type-inference

Можем да правим и така:

    name := "Лили Иванова"
    age := 25

- Сам се усеща какъв тип да сложи на променливата
- Това *НЕ* може да се ползва в глобалния скоуп

.play code/intro/wrong_type_inference.go


* Кастване

Кастването работи, както очаквате:

    number := 42                      // (int=42)
    specificNumber := float64(number) // (float64=42.0)

С тази разлика, че нямате имплицитен каст:

.play code/intro/implicit_cast_error.go

* Strings and runes

- Имаме вградени memory-safe UTF-8 strings
- Един unicode code point се нарича `rune` и се инициализира с единични кавички: `'a',`'ж',`'本',`'\u12e4'`
- String може да се инициализира с двойни кавички или с backticks за literals

.play code/intro/strings_and_runes.go



* Стойности по подразбиране

Не се грижим за това да си инициализираме стойностите. Всяка променлива в Go се инициализира по подразбиране:

    var (
        digit int         // 0
        digit *int        // nil
        number float64    // 0.0
        isIt bool         // false
        name string       // ""
        root complex64    // (0+0i)
        pipe chan <type>  // nil
    )


* Инициализация

- Във всеки пакет може еднократно да се инициализират неща
- Това става с помощта на `init()` функции

.play code/intro/init.go

За разлика от нормалните функции, за които ще си говорим следващия път, можем да имаме няколко `init()` функции в един пакет


* Unused variable

Дефинирана стойност, която не се използва, води до грешка по време на компилация

.play code/intro/unused_var.go

* Константи

Аналогично с var:

    const (
        name string = "Лили Иванова"
        age uint8 = 25
    )

Могат да бъдат само

- bool
- int, int8, int16, int32, int64
- float32, float64
- complex64, complex128
- string


* iota

Нали помните `enum`?

    const (
        Monday = iota
        Tuesday
        Wednesday
        Thursday
        Friday
        Partyday
        Sunday
    )

.link http://en.wikipedia.org/wiki/Iota _Wikipedia:_ Iota is the ninth letter of the Greek alphabet.

* Малко по-сложен пример :)

.play code/intro/iota.go


* Контролни структури


* if

    if age < 13 {
        fmt.Print("Още не си тийнейджър")
    } else if age >= 13 && age < 20 {
        fmt.Print("В момента си тийнейджър")
    } else {
        fmt.Print("Минали са ти тийнейджърските години")
    }

- Няма `(` и `)` около условията
- Отварящата `{` е на същия ред с условието.
- `}`else`{`  трябва да са на един ред
- Ползва се `else`if`, няма `elseif`

* for

Добрия стар `for` от C:

    for i := 0; i < 20; i++ {
        fmt.Println(i)
    }

И точно както в C, някои от аргументите не са задължителни.
\... *някои* да се чете като *всички*.

.play code/intro/endless_for.go /^\s+for {/,/}/

_Забележка:_ Отварящата `{` и тук е на същия ред с условието


* while

Няма. `for` покрива всичките му приложения.


* foreach

Няма. `for` покрива всичките му приложения.


* switch

    switch {
    case age < 13:
        fmt.Print("Още не си тийнейджър")
    case age >= 13 && age < 20:
        fmt.Print("В момента си тийнейджър")
    default:
        fmt.Print("Минали са ти тийнейджърските години")
    }

Няма нужда от излишния `break`

Ако искаме да изпълним два поредни `case-а`, използваме `fallthrough`.


* break и continue

Все пак има `break`, който е приложим за `for` цикли.

`continue` работи, точно както очаквате и където очаквате.


* goto

.image assets/exorcist.jpg

Да, има и такова.

Ако не знаете кога, не го ползвайте.

Към момента допускаме, че още не знаете кога => не го ползвате.


* Особености, с които се сблъскахте (Q&A)


* ;

*Q:* Няма точка и запетая след всеки израз?

*A:* Всъщност има, но е имплицитна.

Сега си спомнете за правилото с отварящата `{`.


* Индентация

*Q:* Интервали vs. Табове?
*A:* Един таб.

* За четене

*Q:* Нещо за четене? Книги? Туториъли?
*A:*

.link https://golang.org/doc/code.html How to Write Go Code
.link https://tour.golang.org/welcome/1 A Tour of Go
.link https://golang.org/doc/effective_go.html Effective Go
.link https://play.golang.org/ Изпънение на Go код с браузър
.link https://blog.golang.org/ Golang Blog

* В следващия епизод:

- Функции
- Указатели