Язык программирования Go

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

• Почему вам стоит изучить Go? (добавлено 24.09.2017)
• Для начинающих:
  • С чего начать новичку в Go - список полезных ссылок для начинающих
  • Учебник по Go
  • Всё, что вы хотели знать про GOPATH и GOROOT (добавлено 24.09.2017)
  • Пример решения типичной ООП задачи на языке Go
  • Как не наступать на грабли в Go
  • Зачем в Go амперсанд и звёздочка (& и *)?
  • Статья Мой путь от Python к Go — делюсь советами и ресурсами (добавлено 10.04.2019)
• Go в примерах (добавлено 16.09.2017)
• Необязательные аргументы в функциях Go (добавлено 14.12.2017)
• Краш-курс по интерфейсам в Go
• Чистая архитектура в Go-приложении
• Почему «ошибки это значения» в Go
• Как писать Go код, который легко портируется
• Интересные способы использования Go каналов (перевод)
• Планировщик Go
• Генерация кода в Go
• Пишем симулятор медленных соединений на Go
• Обновление сервисов, запущенных на Go
• Механизмы выделения памяти в Go (добавлено 12.03.2019)
• Практичный гайд по переменным окружения в Go (добавлено 07.05.2019)
• Разработка веб-серверов на Golang — от простого к сложному (добавлено 07.05.2019)
• Динамическое изменение схемы JSON в Go с помощью gob (добавлено 07.05.2019)
• Профилирование кода (добавлено 18.12.2019):
  • Профилирование кода Go-проекта и решение проблемы с выделением памяти
  • Profiling Go programs with pprof
• Лекции Техносферы: Программирование на Go

Небольшая статья на примере показывающая разницу между копированием значения и обращением по указателю к структуре. И хотя в данном случае всё оказалось достаточно просто, всё же решил сохранить её себе как напоминание, что даже простые ошибки могут приводить к лишним "тормозам" программ.

Также в ней можно почерпнуть начальные знания по профилированию и трассировке escape-анализа.

Сегодня наткнулся на интересную статью про дженерики в языке Go - возможность написав всего одну функцию, использовать её для обработки данных разных типов, сохранив при этом существующие плюсы Go (простоту, безопасность, статическую типизацию и т.п.). Долгое время отсутствие дженериков многими программистами называлось как один из основных недостатков Go, хотя лично мне это никогда особенно не мешало (возможно, просто не было проектов, где это вызывало бы дополнительные сложности).

С большим удовольствием прочитал её и опять немного погрузился в мир Go. Даже немного обидно, что пропустил эту статью, когда она была опубликована прошлым летом. И, хотя в последнее время в основном использую программы/скрипты на python и sql-запросы (для доступа к данным в базах данных), очень надеюсь, что со временем найду и для Go достойное применение.

Полезная статья с описанием методов оптимизации размера Go-бинарника. Основные методы, конечно, известные (применял для программ на Delphi), но здесь рассматриваются именно в применении к Go. Кратко приведу актуальные для меня моменты:

1. Отключение отладочной информации (стриппинг - stripping) - сжатие составило около 30%
   go build -ldflags "-s -w" ./...
2. Сжатие - старый добрый UPX (несколько степеней сжатия, но будет тратиться время на распаковку) - сжатие до 4-х раз
   upx --best --lzma <программа>
3. Отключение тяжёлых зависимостей (если есть внешние модули, от которых можно отказаться).

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

fatal error: concurrent map writes

Падение сервиса с такой ошибкой произошло из-за того, что я не учёл (а точнее пренебрёг из-за малой вероятности) возможность доступа к используемому в программе словарю (map) одновременного из двух потоков (у нас не очень большая интенсивность потока сообщений, суммарным объёмом 12-15 тысяч в день).

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

После изучения официальной документации и прочтения нескольких статей (Golang Maps: Not safe for concurrent use, Танцы с мьютексами в Go, Разбираемся с новым sync.Map в Go 1.9) остановился на использовании мьютексов для создания блокировок при записи в словарь. Это позволило минимальными усилиями защититься от подобных падений в будущем. Так что удалось в очередной раз получить удовольствие от работы на Go и немного улучшить свои познания в нём.

Надеюсь, что обновлённый сервис проработает не меньше, а дополнительно обновлённая система логов позволит легче отвечать на возможные вопросы по его работе.

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

https://habr.com/ru/post/441842/

Содержание:

1. Основополагающие принципы
   1. Простота
   2. Читаемость
   3. Продуктивность
2. Идентификаторы
   1. Именуйте идентификаторы исходя из ясности, а не краткости
   2. Длина идентификатора
   3. Не называйте переменных по их типам
   4. Используйте единый стиль именования
   5. Используйте единый стиль деклараций
   6. Работайте на коллектив
3. Комментарии
   1. Комментарии в переменных и константах должны описывать их содержимое, а не предназначение
   2. Всегда документируйте общедоступные символы
4. Структура пакета
   1. Хороший пакет начинается с хорошего названия
   2. Избегайте названий вроде base, common или util
   3. Быстро возвращайтесь, не погружаясь вглубь
   4. Сделайте полезным нулевое значение
   5. Избегайте состояния уровня пакета
5. Структура проекта
   1. Меньше пакетов, но более крупные
   2. Основной пакет минимально возможного размера
6. Структура API
   1. Проектируйте API, которыми трудно злоупотребить по дизайну
   2. Проектируйте API для основного варианта использования
   3. Пусть функции определяют требуемое поведение
7. Обработка ошибок
   1. Устраните необходимость обработки ошибок, убрав сами ошибки
   2. Обрабатывайте ошибку только единожды
8. Параллелизм
   1. Постоянно выполняйте какую-то работу
   2. Оставьте параллелизм вызывающей стороне
   3. Никогда не запускайте горутину, не зная, когда она остановится

Некоторое время назад попалась задачка, про лотерейные билеты (писал в ЖЖ):

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

Решил её без применения компьютера, но заинтересовало, насколько везучим оказался этот мальчик. В итоге, написал программку для нахождения всех таких пар счастливых билетов. Оказалось, что вероятность небольшая - 1,62%

Скачать программу и исходный текст (1 Мб)

На днях выдалась возможность немного попрограммировать на Go. Нужно было сделать два простеньких web-сервера. Первый собирает из нескольких запросов (XMLHttpRequest) единое сообщение и, когда всё сообщение собрано, передаёт его второму, который вызывает локальную программу с параметрами из этого сообщения.

В общем, все очень просто, но какая-никакая практика, да ещё и получил большое удовольствие.

С удовольствием прочитал статью про рефакторинг программы на Go, приведший в многократному ускорению. Написано очень здорово, всё разделено по шагам, предложенные улучшения просты и понятны.

Несколько недель назад я прочитал статью «Хороший код против плохого кода в Go», где автор шаг за шагом демонстрирует рефакторинг реального приложения, решающего реальные бизнес-задачи. Она сфокусирована на превращении «плохого кода» в «хороший код»: более идиоматичный, более понятный, полноценно использующий специфику языка Go. Но автор также заявлял о важности производительности рассматриваемого приложения. Во мне взыграло любопытство: давайте попробуем её ускорить!

https://habr.com/company/badoo/blog/415919/

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

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

Скачать: программу (750 kb), исходные тексты (1,5 kb)

Неожиданно образовавшееся свободное время решил потратить на самообразование - начал изучать язык программирования go. Для себя выбрал следующий порядок - сначала прочитал и сделал все упражнения по этому учебнику, потом прочитал все статьи из раздела "Для начинающих" (см. ссылки выше). Потом прошёл тур по Go с официального сайта (планирую пройти повторно для закрепления материала). Также начал читать книгу Марка Саммерфильда "Программирование на Go".

В общем, первоначальные базовые знания вроде получил. Теперь думаю, как бы применить их на практике.