Go когда появился: подробная история

Go (Golang) появился 10 ноября 2009 года вместе с первым публичным релизом и выходом в open source, а версия 1.0 была выпущена 28 марта 2012.

Однако история его создания началась двумя годами раньше — в конце 2007-го — как ответ на системный кризис масштабируемости в разработке Google.

Часть 1: Кризис разработки в Google

В 2000–2010 годах проблемы гипер-масштаба внутри Google достигли критической точки: устоявшиеся технологии (C++, Java, Python) перестали соответствовать реалиям эпохи многоядерных процессоров и распределенных систем. Инженеры не решали проблемы по существу, а лишь обходили их. В едином монорепозитории хранились миллионы строк кода, с которым ежедневно работали тысячи сотрудников. Сборки проектов занимали часы, а специальная распределенная система сборки поддерживала этот процесс лишь ценой невероятной сложности.

Но даже самая мощная распределенная система не могла скомпенсировать фундаментальный недостаток C и C++ — архитектуру зависимостей. В основе лежит текстовый препроцессор заложенный ещё в ANSI C в 1989 году: директивы #include с защитой через #ifndef предотвращают ошибки компиляции при повторном включении зависимости, но не отменяют операций на открытие и чтение файлов. Компилятор многократно сканирует одни и те же заголовки, лишь чтобы убедиться, что они “уже обработаны”. У этой проблемы существуют и другие решения, так например в Plan 9 запрещалось вложенные подключения зависимостей и требовалось перечислять все зависимости вверху файлов. Это снижало нагрузку на файловую подсистему при сборке и ускоряло процесс. Однако подобный метод требовал от разработчиков повышенной внимательности и строгой дисциплины, чего сложно достичь в крупных проектах. В итоге кол-во зависимостей продолжало некотнтролируемо расти, потому что программисту было проще добавить лишний #include, чем рисковать сломать сборку или тратить время на оптимизации.

Если смотреть на цифры, ситуация выглядела следующим образом: в 2007 году анализ сборки одного из основных бинарников Google показал что: 4,2 МБ исходного кода превращались в 8 ГБ данных на входе компилятора. Прирост в 2000 раз. Сборка такого бинарника занимала до 45 минут. Это не просто “медленно”, это разрыв цикла обратной связи разрабоки: инженер отправлял код в систему сборки и получал результат лишь через час работы. Проблема вынужденных простоев из-за обработки гигабайтов одних и тех же заголовков показала: просто чинить инфраструктуру уже недостаточно. Требовался не очередной «костыль», а принципиально иное решение масштаба всей компании.

Часть 2: Зарождение идеи. Три титана

Понимание того, что существующие инструменты исчерпали свой ресурс, вылилось в конкретный план действий. 21 сентября 2007 года Роберт Гризмер, Роб Пайк и Кен Томпсон встретились, чтобы набросать цели нового языка. Это не были молодые энтузиасты, жаждущие «попробовать новое». Это ветераны индустрии, на чьем опыте десятилетий строится современный интернет. Они собрались не ради академического эксперимента, а потому что устали от того, что инструменты разработки перестали соответствовать масштабу задач.

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

Все трое хотели создать невозможный гибрид: язык, который обладал бы эффективностью, безопасностью и контролем статически типизированного компилируемого языка (как C/C++), но при этом оставался бы таким же простым, понятным и продуктивным, как динамический язык (например, Python). В Google в 2007 году тысячи инженеров ежедневно писали скрипты на Python ради скорости разработки, но страдали от отсутствия строгой типизации и низкой производительности. С другой стороны, для высоконагруженных сервисов использовали C/C++, который обеспечивал скорость, но превращал процесс написания и поддержки кода в мучительный труд. Задачей “трёх титанов” было соединить эти полюса.

Часть 3: Дизайн-философия Go: «Меньше — экспоненциально больше»

Только через 5 лет в 2012 году Роб Пайк сможет ёмко сформулировать философию языка “Меньше означает экспоненциально больше” (оригинал: “Less is exponentially more”). Каждая новая функция языка, каждый дополнительный оператор или синтаксический сахар в языке программирования взаимодействует не только с разработчиком, но и со всеми остальными возможностями языка. Чем сложнее язык, тем больше комбинаций возникает, и тем больше требуется усилий для понимания кода.

В контексте Google, где над одним проектом могли работать тысячи людей, сложность языка была не просто раздражающим фактором, а угрозой безопасности и стабильности. Новичок не может безопасно изменить код, не понимая, как сложно могут взаимодействовать особенности языка в коде опытного разработчика . Для этого в дизайн Go и закладывался радикальный шаг “назад” в сторону простоты, чтобы сделать два шага “вперед” в сторону эффективности коллективной работы.

Простота как главная ценность: Хроники «запрещенного»

Go вызвал (и продолжает вызывать) бурные споры именно тем, чего в нем нет. Авторы языка сознательно отказались от многих конструкций, ставших «золотым стандартом» в объектно-ориентированном программировании конца 90-х и начала 2000-х.

Самый заметный отказ — это наследование (inheritance). В C++ или Java разработчики строят сложные деревья классов: Animal -> Mammal -> Dog. Теоретически это упрощает повторное использование кода, но на практике приводит к проблеме хрупкого базового класса: изменение в родительском классе может сломать всех потомков в самых неожиданных местах. В Go нет классов и нет наследования. Вместо этого есть простые структуры (structs) и композиция. Вы просто встраиваете один тип в другой. Это делает компоненты слабо связанными между собой, а сама связь становится явной. Что и обеспечивает предсказуемость кода.

Не менее радикальным было отсутствие дженериков (generics) в ранних версиях Go (вплоть до версии 1.18). Это было осознанное решение, а не невозможность реализации. Разработчики понимали, что дженерики добавляют огромную сложность в систему типов и компилятор. Гризмер, Пайк и Томпсон решили, что для задач веб-сервиса и системного программирования простые интерфейсы и срезы (slices) достаточно эффективны, а цена, которую платит сообщество за сложность дженериков, слишком высока. (Хотя позже, спустя десятилетие, язык все же вырос, чтобы включить их, но без ущерба для простоты базового синтаксиса).

И, конечно, это отсутствие исключений (exceptions). В Java и C++ исключения позволяют «бросить» ошибку в одном месте и «поймать» её в другом. Это выглядит элегантно в маленьких примерах, но в коде на миллионы строк это превращается в кошмар. Вы никогда не знаете, вернет ли функция результат или сломается вернув исключение, если не залезете в её документацию или реализацию. В Go явные проверяемые ошибки: функция возвращает значение и ошибку (val, err := foo()). Это заставляет разработчика обрабатывать ошибку в месте вызова. Если вы не хотите обрабатывать ошибку, вы должны описать игнорирование (с помощью конструкции _), явно показывая свое намерение. Это делает поток управления (control flow) читаемым как книга: сверху вниз, без невидимых прыжков.

Мнение, а не конфигурация: Конец священным войнам

Одной из частей работы в любой крупной IT-компании являются бесконечные дебаты о стиле кода. Отступы: табы или пробелы? Где ставить фигурную скобку — на той же строке или с новой? Как называть переменные?

В Go ответ на эти вопросы дали ответ через единое форматирование — gofmt. Это утилита форматирования кода, которая является не рекомендацией, а требованием. В экосистеме Go нет «моего стиля», есть только «стиль Go». Перед коммитом код прогоняется через gofmt, и он приводится к единому стандарту. Инженеры больше не спорят о форматировании, а сосредоточены на логике и архитектуре.

Тот же принцип применим и к системе сборки. В мире C++ существовало множество систем: Make, CMake, Autotools, Bazel, Ninja и другие. Каждая требовала изучения собственного языка скриптов и настройки. В Go появилась одна команда: go build. Она берет исходники, находит зависимости (используя переменную окружения GOPATH, а позже go.mod) и собирает бинарник. Никаких Makefile, никаких сложных конфигураций. Это возможность начать компилировать код через 15 минут после установки компилятора, а не через два дня настройки среды и обучения конкретному инструменту.

Сетевая и многопоточная парадигма с рождения

Многопоточность в традиционных языках (C/C++ и Java до последних версий) — это сложный механизм. Вы работаете с потоками операционной системы. Поток «тяжелый»: ему нужно много памяти под стек (обычно несколько мегабайт), и переключение контекста между потоками требует больших накладных расходов процессорного времени. Если вы хотите обслуживать 10 000 одновременных соединений в C++, вам приходится либо держать 10 000 потоков (что потеницально может израсходовать всю память), либо писать сложнейший асинхронный код с коллбеками, который превращается в «callback hell» и совершенно нечитаем.

Go решил эту проблему иначе, заложив модель CSP (Communicating Sequential Processes) в сам синтаксис языка.

В Go есть горутины (goroutines). Это легкие потоки, управляемые через runtime внутри программы, а не операционной системой. Горутина занимает всего пару килобайт памяти. Вы можете запустить 100 000 горутин в одной программе без негативного влияния на работу операционной системы. Для запуск горутины используется ключевое слово go перед вызовом функции. Например: go processRequest(). Это упрощает написание конкурентного и паралельного кода.

Для коммуникации между потоками в Go существуют каналы (channels). Философия, выраженная в знаменитом лозунге: “Не общайтесь, разделяя память; разделяйте память, общаясь” (оригинал: «Do not communicate by sharing memory; instead, share memory by communicating»).

Вместо того чтобы два потока сражались за доступ к одной переменной, используя мьютексы и семафоры (что является главным источником гонок данных и deadlock’ов), один поток кладет данные в канал, а другой — забирает оттуда. Это безопасно синхронизирует их. Каналы — это типизированные «трубы», которые являются частью самого языка. Такой подход позволил писать высоконагруженные сетевые сервисы, которые используют все ядра процессора, не превращая код в кашу.

Инструментарий — часть языка

Создатели Go понимали, что язык — это не только синтаксис, но и экосистема инструментов и библиотек вокруг него. В Go всё идет «из коробки»:

Явное лучше неявного

Явное возвращение ошибок, о котором мы говорили, — лишь верхушка айсберга. Go никогда не делает скрытых преобразований типов, которые могут привести к потере данных (например, вы не можете неявно преобразовать int в float64 или string в int). Вы должны написать это явно.

Go спроектирован так, чтобы быть скучным. В нём нет магии. Если вы читаете код на Go, он делает ровно то, что написано. Нет скрытых конструкторов, нет перегрузки операторов, которая заставляет вас искать определение + в десятке файлов. Эта «скучность» и есть главная сила Go. Она делает код читаемым не только автору, но и для того кто впервые видит этот проект. А в мире крупномасштабной разработки, время на понимание кода — это дорогой ресурс.

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

Часть 4: Первые шаги: От прототипа к Open Source (2008-2009)

Переход от теоретических набросков к работающему компилятору занял несколько месяцев. В январе 2008 года Кен Томпсон вел работу над первым прототипом. Для упрощения написания бэкенда для генерации машинного кода под каждую архитектуру, он выбрал прагматичный путь: первый компилятор Go переводил код Go в код на языке C, который затем компилировался существующим GCC. Это позволило тестировать синтаксис и семантику языка, не погружаясь в дебри ассемблера на старте разработки.

Если посмотреть в историю коммитов репозитория Go, можно увидеть забавную деталь: первый коммит от 1972 года с подписью Брайана Кернигана и легендарным сообщением «hello, world». Это «пасхальное яйцо» символизировало преемственность идей от Unix-культуры. Но активная работа началась 2 марта 2008 года с коммита Go spec starting point.. Логи показывают, как Роберт Гризмер и Роб Пайк активно формулировали и уточняли спецификацию языка (go_spec), внося правки в грамматику, ключевые слова и синтаксис.

В начале августа 2008 года к проекту присоединился Расс Кокс (Russ Cox), который взял на себя тяжелую работу по развитию библиотек и инструментов, доводя их до состояния, когда ими было удобно пользоваться в реальной инженерной практике. Чуть позже, в сентябре 2008 года, к команде присоединился Иэн Тейлор (Ian Lance Taylor), который начал разработку фронтенда Go для компилятора GCC (gccgo). Это были важные моменты: даже внутри компании проект начал привлекать талантливых инженеров, способных внести значительный вклад в его развитие.

10 ноября 2009 года состоялся публичный релиз. Роб Пайк объявил о Go в официальном блоге Google Open Source. Проект открыли для всего мира. Релиз включал компилятор (gc), компилятор gccgo, стандартную библиотеку и набор инструментов.

Реакция мирового сообщества была смесью интереса и скепсиса. На профильных сайтах и форумах развернулись жаркие дебаты. Многие были сбиты с толку отказом от объектно-ориентированных подходов (наследования) и странной концепцией горутин. Выглядело это как эксперимент, обреченный на успех только в стенах Google. Но, несмотря на скепсис, старт был положен. Разработчики, уставшие от сложности C++ и медлительности интерпертируемых языков, увидели в Go именно то, что им было нужно: простой, быстрый и надежный инструмент.

Часть 5: Путь к зрелости: Go 1.0 и обещание стабильности (2010-2012)

После публичного анонса в ноябре 2009 года язык Go начал планомерно развиваться, решая конкретные проблемы масштабируемости и эффективности разработки внутри Google. В период до выхода версии 1.0 (2012 год) язык и его инструменты эволюционировали, но основной синтаксис и идеи оставались стабильными. Команда разработчиков сознательно фокусировалась на обратной совместимости и практической пригодности, что позволило использовать Go в промышленных проектах еще до официального релиза.

Формальный выпуск версии 1.0 вышедший 28 марта 2012 года стал важным этапом. Главным в релизе были не новые функции, а обещания стабильности и обратной совместимости. Это зафиксировало фундамент языка, его стандартную библиотеку и открыло путь для масштабного использования в высоконагруженных системах как внутри Google, так и за ее пределами.

Авторы языка сделали то, на что осмеливались немногие: они публично заявили, что программы, скомпилированные с Go 1.0, будут компилироваться и работать с любыми последующими версиями Go 1.x. В мире разработки, где переходы с Python 2 на Python 3 или между версиями C++ оборачиваются головной болью и месяцами переписывания кода, это звучало как важное конкурентное преимущество.

Обещание обратной совместимости («Go 1 compatibility promise») решило главную проблему бизнеса: страх устаревания. Технические директора крупных компаний могли теперь с уверенностью инвестировать в инфраструктуру на Go, зная, что их код не устареет через год. Это придало языку вес и серьезность, переведя его из разряда «игрушки» в категорию инструментов для крупного бизнеса.

Гарантия стабильности открыла возможности и для роста экосистемы. Как только правила языка стабилизировались, начался взрывной рост внешних проектов.

К 2014-2015 годам Go перестал восприниматься как «внутренний эксперимент Google» и стал одним из доминирующих языков серверной и системной разработки.

Часть 6: Go покоряет мир: Docker, Kubernetes и экосистема

Go завоевал мир, став невидимым фундаментом, на котором сейчас стоит современный интернет. Язык не пробивался в мобильную разработку и не стал основным для обучения студентов в университетах. Вместо этого он стал языком выбора для инфраструктуры. Язык стал «цементом», на котором строятся облака, контейнеры, системы мониторинга и большинство крупных бизнес-систем. И произошло это не благодаря маркетинговой кампанией Google. Язык выбирали в ходе естественного отбора лучших инструментов для решения сложных инженерных задач.

Docker: Революция в одном бинарнике (2013)

2013 год стал по-настоящему переломным моментом как для языка, так и для всей backend разработки. Компания dotCloud представила миру Docker. Технология контейнеризации существовала и раньше (в виде LXC — Linux Containers), но была сложной, неудобной и доступной только опытным системным администраторам. Docker сделал контейнеры простыми, массовыми, позже они превратились в индустриальный стандарт развёртывания. И всё это было написано на Go.

Почему разработчики Docker выбрали именно Go? Потому что они сталкивались с классической проблемой распространения ПО: «У меня это работает, а на сервере — нет». Приложения на Python или Java требовали установки очень конкретных версий интерпретаторов, библиотек и настройки окружения. Из-за этого было невозможно предсказуемо развёртывать сервисы.

Go предоставлял для этой проблемы идеальное решение: статический бинарник. Программа на чистом Go компилируется в один исполняемый файл, который включает в себя все необходимое для его работы. Этот файл можно скопировать на любой Linux-сервер — он запустится без установки зависимостей, настройки переменных окружения или борьбы с версиями библиотек. Для Docker, который должен был упаковывать и запускать приложения в потеницально самых разнообразных Linux средах, это было критически важным свойством. Успех Docker стал одной из визитных карточек Go. Разработчики по всему миру видели, что возможно через один маленький быстрый бинарник на Go реализовать такое сложное ПО.

Kubernetes: Стандарт де-факто (2014)

Следующим этапов развития можно считать 2014 года, когда Google открыл исходный код Kubernetes — системы оркестрации контейнеров. Если Docker создал «коробку» для приложения, то Kubernetes стал «диспетчером», управляющим миллионами таких коробок в кластере из тысяч серверов. Kubernetes был рожден внутри Google как духовный наследник системы Borg, которая десятилетиями управляла инфраструктурой поискового гиганта.

Kubernetes был написан на Go с первого дня и до последней строчки. Это не было случайным выбором. Создатели Kubernetes (включая Джо Беду, Брэда Фитцпатрика и Бренда Бернса) понимали, что пишут систему невероятной сложности.

Kubernetes закрепил за Go звание языка №1 для облачной инфраструктуры (Cloud Native). Если вы сегодня работаете в облаке (AWS, Azure, Google Cloud), вы, скорее всего, взаимодействуете с сервисами на Go. Планетарный масштаб Kubernetes доказал, что Go готов к задачам, для которых C++ слишком сложен в поддержке, а Java — слишком тяжел для микросервисов. Простота Go разблокировала возможность строить системы совершенно нового уровня сложности.

Экосистема: Появление новых титанов

История успеха Docker и Kubernetes создала прецедент. Инженеры по всему миру поняли: если Google доверяет Go, что бы строить свои ключевые активы. А сам язык позволяет создавать системы совершенно нового класса масштаба. То значит, на нем можно строить всё. Начался бум появления новых проектов, которые сегодня являются стандартами индустрии серврных и облачных вычислений:

Почему именно Go? Инфраструктурный матч

Все эти инструменты объединяет одно: они являются частью «платформы». Платформа должна быть надежной, переносимой и предсказуемой.

  1. Отсутствие «ада зависимостей» (Dependency Hell): Инфраструктурные инструменты часто ставятся на «голые» Linux сервера. Go с его статическими бинарниками решает эту проблему. go build способен давать вам один файл, который просто работает.
  2. Кросс-компиляция: Разработчик на macOS может одной командой собрать бинарник для Linux x64 или ARM64, который пойдет на сервер. Это ускоряет разработку инструментов инфраструктуры в разы.
  3. Производительность ввода/вывода: Задачи инфраструктуры — это почти всегда работа с сетью и диском (чтение конфигов, обработка запросов, репликация данных). Модель конкурентности Go с каналами и горутинами идеально подходит для создания I/O-интенсивных систем, не блокируя основной поток выполнения.

Go не стал популярным, потому что он «приятный» (хотя многие так считают). Он стал популярным, потому что он полезен. Он стал языком, на котором современные инженеры строят инструменты для других инженеров. Революция Cloud Native была совершена на Go.

Часть 7: Go в современном мире: 2015 — настоящее время

К 2015 году прошел пик ажиотажа вокруг «нового языка», и Go вступил в фазу зрелости. Он перестал быть «интересным экспериментом» и превратился в надежную рабочую лошадку индустрии. Однако это не означало, что развитие остановилось. Напротив, последние годы стали периодом самого интересного эволюционирования, когда язык, не теряя своей сути, научился решать задачи, которые казались ему неподвластными.

Эволюция: Медленность как преимущество

Команда разработчиков Go всегда следовала принципу: «Лучше отсутствие фичи, чем плохая фича». Это породило знаменитое ожидание новых функций, которое иногда длится годами. Но когда фича появляется, она работает безупречно.

Самым болезненным вопросом для сообщества долгое время было управление зависимостями. До версии 1.11 разработчики боролись с $GOPATH и сторонними инструментами вроде dep. Наконец, в релизе 1.11 (август 2018 года) появились Go Modules. Это была революция в управлении пакетами: зависимости описывались явно в файле go.mod, код больше не обязан был находиться в строго определенной директории, а проблемы «вендоринга» ушли в прошлое. Модули окончательно сделали Go удобным для работы над множеством проектов и закрыли один из ключевых аргументов критиков.

Еще более долгим путем шли дженерики (generics). Десять лет Роб Пайк и другие члены команды сопротивлялись их внедрению, опасаясь чрезмерного усложнения языка. Но к 2020-м годам стало ясно, что копипаст кода (для реализации структур данных на основе срезов) стал новой формой сложности. В марте 2022 года, в версии Go 1.18, дженерики все-таки появились. Они были добавлены с невероятной осторожностью, чтобы не ломать существующий код и не превращать Go в C++. Сегодня это элегантный, но мощный инструмент создания библиотек, который разработчики используют сознательно и только там, где это действительно нужно.

Расширение экосистемы: От инфраструктуры к бизнес-логике

Если в начале 2010-х Go был языком для тех, кто пишет инструменты, то сегодня он — основной выбор для написания самих сервисов.

Кто использует Go? Голос кошелька

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

Go в России

В России Go также занял доминирующие позиции в сегменте high-load и финансового сектора.

Сегодня Go больше не «вызов» или «альтернатива». Это стандарт де-факто для новых облачных проектов. Он доказал, что сочетать простоту разработки с производительностью системного языка — не просто мечта, а реальность, на которой работает современный интернет.

Часть 8: Критика и вызовы

Несмотря на феноменальный успех, у Go есть свои «ахиллесовы пяты», и язык часто подвергается критике. Иногда претензии носят эстетический характер, а иногда — фундаментальный.

Самая известная причина для шуток в сети — это многословность кода из-за обработки ошибок. Отсутствие исключений вынуждает разработчиков повсеместно писать конструкции if err != nil. В больших функциях это создает лес из проверок, который занимает экран и сбивает суть логики. Хотя это делает код надежным и явным, многие считают это шагом назад в продуктивности.

Также долгое время (до версии 1.18 в 2022 году) язык критиковали за отсутствие дженериков, что приводило к дублированию кода или работе с пустым интерфейсом interface{}, теряя статическую типизацию. Хотя дженерики появились, их реализация скромна и намеренно проста, что не всегда покрывает сложные сценарии метапрограммирования, доступные в C++ или Rust. Кроме того, стандартная библиотека Go, будучи мощной для сетевых задач, иногда уступает в богатстве готовых решений для сложной математики, GUI или специфических бизнес-задач по сравнению с экосистемой Java или Python.

Серьёзным вызовом в нише системного программирования для Go стал Rust. Rust занял нишу системного программирования, обещая безопасность памяти и производительность C++ без сборщика мусора. Для задач, где критически важна детерминированная задержка (deterministic latency) и нельзя допустить паузы сборщика мусора (например, в высокочастотном трейдинге, драйверах устройств или ядрах ОС), Rust выигрывает у Go.

Go проигрывает и там, где требуется максимально тонкий контроль над железом, что остается за современным C++ и новым языком Zig. Однако выбор языка — это всегда компромисс. Go сознательно жертвует микро-оптимизациями и сложными абстракциями ради скорости разработки и легкости поддержки. Если вам нужен безопасный системный язык или вы пишете браузерный движок — это Rust. Если вы пишете микросервисы, CLI или облачную платформу, где время выхода на рынок (TTM) важнее экономии 2% оперативной памяти, — Go остается вне конкуренции.

Часть 9: Заключение. Почему Go — это больше, чем язык

Подводя итог, история Go — это не история академического прорыва в Computer Science. Это история блестящего инженерного ответа на реальные, «земные» проблемы крупномасштабной разработки. Go родился не в теоретической лаборатории, а в «окопах» инженерной борьбы с техническим долгом и сложностью систем национального и планетарного мастштаба. Он не пытался быть самым умным или самым выразительным языком; его цель была прагматичной — дать в руки индустрии инструмент, который быстро работает, на котором быстро писать и который не устаревает.

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

Сегодня Go — это «невидимый цемент облачной эпохи». Он фундамент, на котором построены ключевые технолгии, критически важные части интернета и современной цифровой экономики как таковой. Мы не думаем о фундаменте, когда находимся в здании, но именно на нем держится конструкция. То же самое с Go. Его путь — это доказательство того, что в мире постоянно растущей сложности побеждает дисциплина и простота. Go сделал сложное — доступным, а простое — масштабируемым.

Похожие:

Теги: