Язык программирования go: мнения и перспектива

Создан для слабых программистов?

Go очень просто научиться, настолько просто, что введение заняло у меня один вечер, после чего уже мог продуктивно писать код. Книга по которой я изучал Go называется An Introduction to Programming in Go (перевод), она доступна в сети. Книгу, как и сам исходный код на Go, легко читать, в ней есть хорошие примеры кода, она содержит порядка 150 страниц, которые можно прочесть за раз. Сначала эта простота действует освежающе, особенно в мире программирования, полного переусложненных технологий. Но в итоге рано или поздно возникает мысль: «Так ли это на самом деле?»

Google утверждает, что простота Go — это подкупающая черта, и язык предназначен для максимальной продуктивности в больших командах, но я сомневаюсь в этом. Есть фичи, которых либо недостает, либо они чрезмерно подробны. А все из-за отсутствия доверия к разработчикам, с предположением, что они не в состоянии сделать что-либо правильно. Это стремление к простоте было сознательным решением разработчиков языка и, для того, чтобы полностью понять для чего это было нужно, мы должны понять мотивацию разработчиков и чего они добивались в Go.

Так для чего же он был создан таким простым? Вот пара цитат Роба Пайка (прим.пер.: один из соавторов языка Go):

Что? Так Роб Пайк в сущности говорит, что разработчики в Google не столь хороши, потому они и создали язык для идиотов (прим.пер.: dumbed down), так чтобы они были в состоянии что-то сделать. Что за высокомерный взгляд на собственных коллег? Я всегда считал, что разработчики Google отобраны из самых ярких и лучших на Земле. Конечно они могут справиться с чем-то посложнее?

Glade

Есть такая вещь для Gtk+ 3 — Glade. Это конструктор графических интерфейсов для GTK+. Выглядит примерно так:

Чтобы вручную не создавать каждый элемент и не помещать его потом где-то в окне с помощью программного кода, можно весь дизайн накидать в Glade. Потом сохранить всё в XML-подобный файл *.glade и загрузить его уже через наше приложение.

Установка Glade

В дистрибутивах GNU/Linux установить glade не составит труда. В какой-нибудь Ubuntu это будет:

В Arch Linux:

macOS

В загрузках с официального сайта очень старая сборка. Поэтому устанавливать лучше через Homebrew:

А запускать потом:

Windows

Скачать не самую последнюю версию можно здесь. Я лично на Windows вообще не устанавливал, поэтому не знаю насчёт стабильность работы там Glade.

Простое приложение с использованием Glade

В общем надизайнил я примерно такое окно:

Сохранил и получил файл :

То есть у нас получилось окно (), в котором внутри контейнер (), который содержит поле ввода (), кнопку () и метку (). Кроме этого ещё имеются аттрибуты отсупов (я настроил немного), видимость и другие аттрибуты, которые Glade добавила автоматически.

Давайте теперь попробуем загрузить это представление в нашем :

Снова запускаем:

И получаем:

Ура! Теперь мы представление формы держим XML-подобном файле, а код в !

Пример использования

В языке go отсутствуют такие понятия, как класс, конструктор и деструктор (вместе с соответствующими зарезервированными словами). Однако в нем существуют структуры, позаимствованные из языка С, к которым можно привязать функции, поэтому в go можно создавать код и в стиле ООП. Наличие «сборщика мусора» упрощает работу с памятью, по сравнению с C или С++. Существуют и указатели, но арифметика для них не предусмотрена. Поэтому, даже зная адрес переменной, перемещаться в памяти относительного него невозможно. Это сделано из соображений безопасности. Сравнивая язык go с С++, стоит упомянуть о невозможности перегрузки функций и об отсутствии определяемых пользователем операций. Нет также заголовочных файлов и неявного преобразования типов. Многопоточность поддерживается на уровне языка, для связи потоков используются каналы. Они будут рассмотрены более подробно ниже.

В листинге 1 представлен пример программы на языке go, который будет понятен любому программисту, знакомому с синтаксисом C.

Листинг 1. Первое знакомство с go

package main

import "fmt"

func main() {
        fmt.Println("Hello, World")
}

Для работы с языком go потребуется установить следующее программное обеспечение:

• GCC;
• стандартная библиотека С;
• генератор bison;
• make;
• awk;
• редактор ed.

На платформе Ubuntu/Debian для этого используется следующая команда:

sudo apt-get install bison ed gawk gcc libc6-dev make.

Затем необходимо загрузить из репозитария дистрибутив языка go. Для этого используется Mercurial – мультиплатформенная распределённая система управления версиями, которую можно загрузить командой:

sudo apt-get install mercurial.Mercurial

Следующая команда загружает уже непосредственно сам язык:

$ hg clone -r release https://go.googlecode.com/hg/ go

Последний параметр — это имя каталога, в который будет установлен go. В данном примере подразумевается, что установка ведется из домашнего каталога пользователя и изначально каталога go нет. В противном случае могут возникнуть проблемы, так как по умолчанию go считает, что он установлен в каталоге $HOME/go. Если установить дистрибутив go в другой каталог, то его надо указать в переменной окружения $GOROOT, как показано ниже.

export GOROOT=$HOME/goX.

После получения дистрибутива можно переходить к сборке go:

$ cd go/src
$ ./all.bash

На этом этапе будут собраны соответствующие библиотеки и исполняемые файлы. Если в конце в консоли будет напечатано сообщение ALL TESTS PASSED, то сборка прошла успешно, и можно приступать к программированию на go. Если возникают ошибки, это может быть связано с отсутствием инструментов, перечисленных выше. Также при отсутствии подключения к Интернет могут возникнуть ошибки при прохождении автоматизированных тестов, но это не является критичным для дальнейшей работы.

После этих действий код из листинга 1 можно сохранить в файле с именем hello.go и добавить значение $HOME/go/bin в переменную $PATH. В листинге 2 показано, как выполнить компиляцию и запуск go-программы на 32-битной версии Linux.

Листинг 2. Компиляция и запуск go-программы

//компиляция исходного кода
$ 8g hello.go
//компоновка
$ 8l hello.8
//запуск исполняемого файла
$ ./8.out
//результат работы программы
Hello, World

Как видно, процесс компиляции и запуска в языке go совпадает с процессом, использующемся в языках С/С++. Для других платформ будут использоваться другие версии компилятора и компоновщика: 6g/6l для amd64 и 5g/5l для arm.

Вендоринг

Модули Go по умолчанию игнорируют каталог . Идея в том, чтобы постепенно избавиться от вендоринга. Но если мы все ещё хотим добавить «отвендоренные» зависимости в наш контроль версий, мы можем это сделать:

Команда создаст каталог в корне нашего проекта, содержащий исходный код всех зависимостей.

Однако, по умолчанию все ещё игнорирует содержимое этого каталога. Если вы хотите собрать зависимости из каталога , надо об этом явно попросить.

Я предполагаю, что многие разработчики, желающие использовать вендоринг, будут запускать , как обычно, на своих машинах и использовать на своих CI.

Повторюсь, модули Go уходят от идеи вендоринга к использованию прокси для модулей для тех, кто не хочет напрямую зависеть от вышестоящих служб контроля версий.

Есть способы гарантировать, что будет недоступна сеть (например, с помощью ), но это уже тема следующей статьи.

Управление памятью

Управление памятью вообще заслуживает отдельной статьи. Если в языках типа C++, управление полностью отдано на откуп разработчика, то в более поздних языках типа DELPHI, была использована модель подсчета ссылок. При таком подходе не допускалось циклических ссылок, поскольку образовывались потерянные кластера, то в Go встроено детектирование таких кластеров (как в C#). Кроме того, по эффектвности garbage collector превосходит большинство известных на текущий момент реализаций и уже может быть использован для многих real time задач. Язык сам распознает ситуации, когда значение для хранения переменной может быть выделено в стеке. Это уменьшает нагрузку на менеджер памяти и повышает скорость работы программы.

Оптимизация под типы данных

Чтение и запись порциями могут быть утомительны, если всё что вам нужно это один байт или руна (). В Go для этого есть интерфейсы, которые облегчают жизнь.

Работа с индивидуальными байтами

Интерфейсы и предоставляют простые методы для чтения и записи одного байта:

Заметьте, что тут нет параметра для количества байт, это всегда будет 0 или 1. Если байт не был прочитан или записан, возвращается ошибка.

Также есть есть интерфейс, позволяющий удобно работать с буферизированными ридерами для байт:

Этот интерфейс позволяет вернуть байт обратно в поток. Это бывает удобно, например при написании LL(1) парсеров, так как позволяет заглядывать на байт вперёд.

Работа с индивидуальными рунами

Если вы парсите Unicode данные, то вы должны работать с рунами вместо индивидуальных байт. В этом случае вы должны использовать интерфейсы и :

Версия 6

Ещё один вариант, который я хотел бы протестировать это инициализация параметров цепочкой

Я забыл, как этот паттерн называется, но и не важно, потому что паттерны должны рождаться из кода, а не наоборот

Идея в том, что при создании объекта, мы его возвращаем, и тут же можем вызывать метод-сеттер, который возвращает изменённый объект – и так один за другим:

или

Тогда наш код для Scaffold-виджета будет выглядеть вот так:

Это тоже не сильно чужеродный концепт для Go – многие библиотеки его используют для опций конфигурации, например. Он синтаксически несколько отличается от Dart-версии, но всё таки обладает всеми необходимыми свойствами:

• явное построение дерева
• именованные «параметры»
• отступы помогающие понять глубину виджета
• возможность указывать обработчики и произвольный код

Также во всех примерах мне нравится использование классического именования для конструкторов – просто функция, которая создаёт объект. Это сильно проще объяснять новичку в программировании, чем объяснять конструкторы — «это тоже функция, но у неё имя такое же, как у класса, но ты не увидишь эту функцию, потому что она специальная, и просто глядя на функцию, ты не можешь легко понять – это функция или конструктор объекта с таким именем».

Так или иначе, из всех вариантов, 5-й и 6-й мне кажутся наиболее привлекательными.

Финальная версия кода

Соберём все части вместе и попробуем записать наш «hello, world» на воображаемом Flutter на Go:

main.go

app.go:

home_page.go:

Очень даже ничего!

Заключение

Похожесть с Vecty

Я не мог не обратить внимание на то, как сильно моё решение напоминает то, как мы пишем код на Vecty. Во многом, они, в принципе, похожи, только Vecty выводит результат в DOM/CSS/JS, а Flutter под собой несёт мощный и написанный с нуля движок рендеринга и анимаций, дающий красивейшую графику и крутую анимацию на 120 кадрах в секунду

Но мне кажется, что дизайн Vecty очень удачен, и моё решение для Flutter на Go напоминает Vecty неспроста.

Лучшее понимание дизайна Flutter

Этот мысленный эксперимент был интересен сам по себе – не каждый день приходится писать код на фреймворке, которого не существует. Но он также заставил меня глубже копнуть дизайн и техническую документацию Flutter, чтобы лучше понять что стоит за той скрытой магией.

Недостатки Go

Отвечая на вопрос «Может ли Flutter быть реализован на Go?» мой ответ однозначное «да», но я, безусловно, предубеждён, наверняка ещё не знаю массу ограничений и требований, стоящих перед Flutter, и, вообще, такие вопросы не имеют «правильного» ответа всё равно. Я больше был заинтересован в том, что именно в Go хорошо или плохо ложится на нынешний дизайн.

Эксперимент продемонстрировал, что наибольшая проблема с Go была исключительно в синтаксисе. Невозможность вызывать функцию и передать имена параметров создала существенные затруднения в дизайне читабельного и понятного дерева виджетов. Есть предложения по добавлению именованных параметров в будущие версии Go, и, похоже, эти изменения даже обратно-совместимые. Но их добавление – это ещё одна вещь для изучения, ещё один выбор перед каждой функцией и так далее, так что кумулятивная польза не так уж очевидна.

Мысли о будущем Flutter

Мои заключительные мысли будут о том, что Flutter необыкновенно хорош, несмотря на всё то бурчание, которое я себе позволил в этой статье. Соотношение «крутота/так себе» на удивление велико, и Dart достаточно легко схватывается (как минимум, людям, знакомым с другими языками программирования). Учитывая браузерную родословную Dart, я мечтаю, что однажды все браузерные движки (хотя, сколько их там осталось) будут идти с DartVM вместо V8, и Flutter будет интегрирован нативно – и все Flutter приложения автоматически будут также и веб-приложениями.

Работа, проделанная над фреймворком просто астрономическая. Это проект высочайшего качества и с отличным и растущим комьюнити. Как минимум, количество неоправданно качественных материалов и туториалов просто ошеломительное как для фреймворка, версия 1.0 которого вышла меньше месяца назад. Надеюсь, когда-нибудь также внести свою лепту в проект.

Для меня это game changer, и я надеюсь освоить Flutter настолько, насколько возможно и писать мобильные приложения для себя и ради удовольствия, ибо это больше не будет удел компаний со штатом мобильных разработчиков.

Даже если вы никогда не видели себя в качестве разработчиках мобильных UI – попробуйте Flutter, это глоток свежего воздуха.

• https://flutter.io
• Flutter Tutorial for Beginners — Build iOS and Android Apps
• Go proposal: An Improved, Golang-Cohesive Design for Named Arguments
• Go proposal: spec: untyped composite literals

Пакеты

Представленной информации вполне достаточно для создания простейших программ, поэтому можно перейти к обсуждению архитектуры go-программы. Каждая программа – это пакет (см. в листинге 1), а точнее набор пакетов. Программы собираются из пакетов, и то, что обычно называется библиотеками, в go называется набором пакетов.

Исполняемая программа должна иметь пакет и метод , с которого начинается выполнение программы, и по завершении которого программа закрывается. Выражение дает доступ к методам, переменным и константам пакета . Обращаться к ним следует через оператор (точка), например, .

Область видимости в go несколько отличается от таковой в языке С. Внутри пакета все переменные, функции, константы и типы имеют глобальную видимость. Но для обращения к ним из клиента, импортировавшего этот пакет, имена последних должны начинаться с большой буквы.

Например, клиент импортировал пакет package, в котором объявлены следующие переменные:

const hello = “Im not visible in client, just in package” //видна только в пакете
const Hello = “I can say hello to client” //видна также при импорте

Хотя язык go достаточно молод, он уже имеет обширную библиотеку пакетов. Выше использовался пакет , предназначенный для форматированного ввода/вывода. Пакет предоставляет доступ к файлам, аргументам командной строки, позволяет запускать другие программы и т.д. Есть пакеты для шифрования, сжатия, кодирования и журналирования. Отдельного внимания заслуживают пакеты , , для работы с сетью, позволяющие без особых усилий создавать Web-приложения. В стандартной поставке есть даже пакет для работы с изображениями. После установки в каталоге $HOME/go появляется каталог pkg, в котором есть каталог, соответствующей архитектуре. В этом каталоге выполняется хранение и поиск пакетов.

Горе управления зависимостями

У Go есть встроенная система зависимостей, построенная поверх популярных хостингов VCS. Поставляемые с Go инструменты знают об этим сервисах и могут скачивать, собирать и устанавливать из них код одним махом. Хотя это и здорово, есть крупная оплошность с версионированием! Да действительно, можно получить исходный код из сервисов вроде github или bitbucket с помощью инструментов Go, но нельзя указать версию. И снова простота в ущерб полезности. Я не в состоянии понять логику подобного решения.

После вопросов о решении этой проблемы, команда разработки Go создала , в которой изложили, как они собираются обойти этот вопрос. Их рекомендация была просто однажды скопировать весь репозиторий себе в проект и оставить «как есть». Какого черта они думают? У нас есть потрясающие системы контроля версий с отличным теггированием и поддержкой версий, которые создатели Go игнорируют и просто копируют исходные тексты.

Обновление модулей

По умолчанию, Go не обновляет модули без спроса. «И это хорошо», поскольку нам всем хотелось бы предсказуемости в наших сборках. Если бы модули Go обновлялись бы автоматически каждый раз, когда выходит новая версия, мы вернулись бы в «тёмные века до-Go1.11». Но нет, нам надо сообщить Go, чтобы он обновил для нас модули.

А сделаем мы это с помощью нашего старого друга — :

• запускаем , чтобы использовать последний минорный или патч- релиз (т.е. команда обновит с 1.0.0 до, скажем, 1.0.1 или до 1.1.0, если такая версия доступна)

• запускаем чтобы использовать последнюю патч-версию (т.е. пакет обновится до 1.0.1, но не до 1.1.0)

• запускаем , чтобы обновиться до конкретной версии (например, )

В этом списке нет способа обновиться до последней мажорной версии. На то есть весомая причина, как мы вскоре увидим.

Поскольку наша программа использовала версию 1.0.0 нашего пакета и мы только что создали версию 1.0.1, любая из следующих команд обновит нас до 1.0.1:

После запуска (допустим, ), наш изменился:

Минусы языка Go

В качестве негативной стороны Go часто называют его малую на данный момент распространенность – действительно, есть куда более распространенные языки программирования, которые используются для выполнения большинства задач. Значит ли это, что изучать Go не стоит? Совсем нет. Существует множество корпораций, которые используют язык Go в своих разработках. В первую очередь это, конечно же, Google Inc., а также Basecamp, BBC Worldwide, Canonical, DigitalOcean, Dropbox, eBay, Yahoo и многие другие компании по всему миру. Поэтому перспективы у этого языка программирования точно есть. Безусловно, программисты Go могут быть менее востребованы, чем, к примеру, PHP-разработчики, однако и конкуренция ниже, а значит, выше шанс найти интересную и хорошо оплачиваемую работу.

Те, кто пытается предугадать перспективы языка Go, также говорят о другом минусе, который фактически является противоположностью предыдущего пункта: из-за легкости языка, а значит, низкого порога вхождения количество людей, программирующих на Go, будет расти в геометрической прогрессии, при этом качество кода и сами проекты будут оставлять желать лучшего. Похожая ситуация в начале XXI века случилась с PHP, когда на этом языке стало писать множество начинающих программистов, не очень волнующихся за работоспособность своего кода (и готовых получать небольшую плату за свой труд). Отличие PHP от Go на данный момент заключается в том, что PHP в итоге стал полноценным языком с богатой инфраструктурой и множество фреймворков, без знания которых вы едва ли найдете хорошую работу. Go же позиционируется как простой язык, поэтому перспективы его развития не очень определены.

В рамках данной статьи я не буду останавливаться на сугубо технических моментах, которые вызывают недоумение у программистов, так как это абсолютно субъективные впечатления. Вопросы часто вызывает система типов, отсутствие дженериков, перегрузки операторов, возможности расширить ключевые слова, а также многое другое. Безусловно, Go не является идеальным языком, и при первом знакомстве с ним кому-то может не понравится различия с более привычным ему языком программирования.

Go с предлогами to, on, for

Go + to используется, когда идет речь о движении к определенному месту, выраженному существительным.

Обратите внимание, что перед существительным может быть артикль. Подробно об этом рассказано в видеоуроке:. https://www.youtube.com/embed/gDLX3jqkEhI

В ряде случаев артикль после go to не употребляется:

Go to:

• class – идти на урок,
• work – идти на работу,
• school / college / university – идти в школу, колледж, университет.
• bed – идти спать (букв: идти в кровать),
• prison / jail – отправляться в тюрьму (сесть в тюрьму).
• Washington,  Amsterdam, Japan, Italy, Europe, Asia

В видеоуроке выше учитель приводит примеры употребления неопределенного артикля перед существительным:

Go to a:

• party – идти на вечеринку,
• conference – идти на конференцию.
• concert – идти на концерт.

Go to the:

• doctor – идти к доктору,
• dentist – идти к дантисту,
• specialist – идти к специалисту,
• bank – идти в банк,
• supermarket / mall – идти в супермаркет, торговый центр,
• airport – идти (ехать) в аэропорт.

Эти существительные употребляются с определенным артиклем, потому что в большинстве случаев мы все-таки говорим о конкретном докторе, банке, супермаркете или аэропорте. Если же вы в незнакомом городе и вам нужно в какой-нибудь (любой) банк, то будет “go to a bank”.

С предлогами on, for глагол go употребляется в устойчивых сочетаниях:

Go on:

• holiday – уходить в отпуск,
• a trip – отправляться в поездку,
• a tour – отправляться в тур, экскурсию,
• a cruise – отправляться в круиз.
• strike – идти на забастовку, объявлять забастовку.

Go for:

• a walk – идти на прогулку,
• a run – идти на пробежку,
• a drive – идти на поездку,
• a picnic – идти на пикник.

Создание модуля

Первым делом создадим наш пакет. Назовём его «testmod». Важная деталь: каталог пакета следует разместить за пределами вашего , потому что, внутри него по умолчанию отключена поддержка модулей. Модули Go — это первый шаг к полному отказу в будущем от .

Наш пакет весьма прост:

Пакет готов, но он ещё пока не является модулем. Давайте исправим это.

У нас появился новый файл с именем в каталоге пакета со следующим содержимым:

Немного, но именно это и превращает наш пакет в модуль.

Теперь мы можем запушить этот код в репозиторий:

До сих пор, любой желающий использовать наш пакет применил бы :

И эта команда принесла бы самый свежий код из ветки . Такой вариант все ещё работает, но лучше бы нам так больше не делать, ведь теперь «есть способ лучше». Забирать код прямо из ветки , по сути, опасно, поскольку мы никогда не знаем наверняка, что авторы пакета не сделали изменений, которые «сломают» наш код. Для решения именно этой проблемы и были придуманы модули Go.

Код, написанный на Go, легко поддерживать.

Нет классов. Каждая вещь делится только на пакеты. Вместо классов Go использует только структуры (structs. — прим.перев.).

Не поддерживает наследование. Это упрощает модифицирование кода. В других языках, типа Java/Python, если класс ABC наследует класс XYZ, и вы при этом делаете какие-то изменения в классе XYZ, то это производит дополнительное изменения во всех наследованных от него классах

К тому же, без наследования, код Go становится более простым для понимания (так как нет super классов, на которые нужно обращать внимание при изучении участков кода).
Нет конструкторов.
Нет аннотаций.
Нет дженериков (универсальных шаблонов. — прим.перев.).
Нет исключений.

Читабельность кода против его производительности.win-win. — прим.перев.другом новом языке Swift

Плюсы языка Go

У языка Go есть несколько положительных черт, выделяемых программистами, которые на нем пишут.

Во-первых, это его простота. Язык Go разрабатывался в качестве замены C: его высокая производительность почти сопоставима с языком Си, но более простой синтаксис дает возможность разрабатывать приложения гораздо быстрее (к примеру, как на Python). При этом многие разработчики изучают этот язык после Python или PHP либо используют два языка в связке (Python/Go и PHP/Go)

Упрощенный синтаксис облегчает не только написание своего собственного кода, но и чтение кода, написанного другими программистами, что особенно важно в командной работе

Эта особенность Go, в свою очередь, ведет к другому важному факту: быстрое освоение Go позволяет перевести внимание с изучения самого языка на изучение программирования в целом

Программисты постоянно сравнивают язык Go с другими языками: в его пользу свидетельствует тот факт, что, к примеру, в PHP существует 67 ключевых слов, а в Go их всего лишь 25.

Тут необходимо сделать отступление и сказать о том, что желание создать простой язык программирования родилось у разработчиков Google неслучайно: изначально они задумывали Go как быстро изучаемый язык, который запросто могут выучить несколько не очень опытных программистов для того, чтобы затем вместе писать какое-нибудь приложение. Именно поэтому некоторые считают язык Go языком, пригодным для больших корпораций, где в разработке продуктов будет участвовать множество разных людей. Как уже было замечено выше, простой и понятный синтаксис ведет к тому, что программистам Go не нужно вводить какие-то другие стандарты, обозначения или комментарии – они и без этого отлично поймут код друг друга. Многословность Go радует одних разработчиков и огорчает других, но именно благодаря ей код Go читается так легко.

Поэтому некоторые компании (к примеру, CrowdStrike) сознательно переходят с других языков программирования на Go для того, чтобы в дальнейшем более легко расширять пул своих разработчиков.

Во-вторых, Go имеет большое количество библиотек, благодаря которым можно выполнить практически любую поставленную задачу. Многое можно реализовать, используя только стандартную библиотеку Go, которая легко читается, а также отличается хорошим качеством и скоростью. Отдельного внимания заслуживает эффективное взаимодействие с библиотеками языка Си; некоторые отмечают, что Go-библиотеки по факту являются просто обертками над С-библиотеками.

В-третьих, Go это компилируемый язык, на котором можно быстро написать необходимое приложение. Go имеет такую же строгую статическую типизацию, как Pascal, но в то же время он имеет гораздо больший прикладной характер (и это роднит его с Python). Тут необходимо отметить высокую производительность Golang, которая характерна для компилируемых языков. Также в Go значительно облегчена кроссплатформенность.

Нельзя не отметить и четкую направленность языка Go: в отличие от PHP, на котором пишут большие проекты, Go больше предназначен для некрупных сервисов, которые необходимо быстро написать и внедрить, но которые должны отличаться чрезвычайной надежностью (так называемое robust software).

Развертка Go-приложения также выглядит намного проще, чем развертка приложения, написанного на PHP. Программируя на Go, вы можете создать артефакты для всех операционных систем или архитектур процессора, вам не нужно будет устанавливать Go на используемые вами сервера.

Синтаксис Go может быть непривычен тем, кто до этого программировал на PHP или Python. Если рассматривать код Go в сравнении с PHP, то Go не имеет объектов или классов, зато в нем есть структура, а точнее тип, который содержит именованные поля:

type Circle struct {
 x, y, r float64
}

Еще одной причиной, по которой Go завоевывает все большую популярность, является наличие go fmt – инструмента, который помогает стандартизировать код. А использование go vet поможет вам найти возможные проблемы в коде. Иными словами, авторы языка Go попытались максимально упросить задачу разработки приложений на этом языке, особенно для новичков.

Именно поэтому многие на данный момент считают Go одним из лучших языков программирования и советуют изучать его не только студентам, но и школьникам. Кстати, такой прецедент уже был: учитель научил несколько 11-летних школьников писать и разбираться в коде на таком уровне, что они смогли написать генератор фракталов Мандельброта. А главное, для этого ему понадобилось всего 12-13 часов!