Заброшенные репозитории на GitHub. Какие языки теряют разработчиков и когда код перестают обновлять

Введение

В прошлой статье на основе данных GitHub мы провели анализ популярности языков программирования по числу новых репозиториев поквартально. Получилось любопытно. JavaScript впереди, TypeScript растет втрое, Ruby проседает. Тот рейтинг отвечал на вопрос, где сейчас создают новое. За кадром осталось всё остальное, а именно что происходит со старыми проектами, живут они или тихо превращаются в цифровую археологию.

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

Те же 20 языков, но теперь смотрим не на создание, а на угасание. Какая доля публичных репозиториев на каждом языке давно не получала новых отправок, и как этот показатель меняется, если уравнять проекты по возрасту и по популярности. И отличается ли в этом смысле массовая учебная разработка от серьёзных проектов с тысячами звёзд. Разница, как окажется дальше, заметная, и она показывает не совсем то же самое, что предыдущий рейтинг.

Сразу про ограничения, чтобы потом к ним не возвращаться. Метрика «не было отправок больше года» если мы пытаемся определить заброшенные репозитории GitHub сама по себе грубая. Существуют законченные библиотеки, которым обновляться попросту незачем, например, небольшие утилиты типа is-even в npm. Существуют спецификации и учебные репозитории, которым меняться по определению не нужно. Все они в нашей метрике также попадают в «заброшенные», хотя по сути живы.

Само собой, GitHub это не весь мир разработки. Корпоративный код на Java и C# давно живёт в GitLab, Bitbucket и внутренних установках. Китайские разработчики массово пользуются Gitee. Так что когда дальше окажется, что 84% публичных Java-репозиториев не получали отправок больше года, имеется в виду только публичная активность на GitHub. В корпорациях на ней по-прежнему активно пишут, просто наружу код не выкладывают.

Собранные нами данные могут быть полезны в нескольких случаях. Первый касается выбора зависимостей. Библиотека на TypeScript с 5000 звёзд, появившаяся в 2023 году, скорее всего будет жить и через пару лет, а Scala с 800 звёздами из 2017 года почти наверняка уже не поддерживается, даже если выглядит активной. Второй про выбор языка для нового проекта в долгосрочной перспективе. Цифры по притоку новых популярных проектов и доле архивированных дают неплохое представление о том, куда движется экосистема. И, наконец, просто понимание того, как языки живут и умирают. Каждый, как выяснится, по-своему.

Сервер и окружение

Задача чисто аналитическая и нетребовательная, так что особых требований к железу нет. Запускать сбор можно где угодно, подойдёт обычный ноутбук, домашняя машина или виртуальный выделенный сервер (VPS). Графический процессор не нужен, двух виртуальных ядер и четырёх гигабайт оперативной памяти хватает с запасом. Зависимости необходимо установить минимальные.

pip install requests tqdm pandas matplotlib seaborn

Сам сбор у нас шёл на отдельном сервере с Ubuntu и JupyterLab, и вынесли его туда по бытовым причинам. Сбор занимает около получаса, и в это время не хочется занимать рабочий ноутбук. CSV-файлы удобно держать рядом с ноутбуком, где строятся графики. А если позже захочется поставить сбор на планировщик и обновлять данные раз в месяц, ничего переносить не придётся. На локальной машине всё работает точно так же, просто для регулярных прогонов это менее удобно. Виртуальный выделенный сервер (VPS) с готовым образом Anaconda и JupyterLab разумен ровно в этом случае, когда нужна изолированная песочница или прогон по расписанию.

Для запросов к GitHub нужен Personal Access Token, он создаётся за минуту в настройках профиля, достаточно прав на чтение публичных репозиториев. Без токена лимит 60 запросов в час, с токеном 5000 для основного программного интерфейса (API) и около 30 в минуту для поискового интерфейса GitHub (Search API). На все три этапа сбора уходит примерно полчаса.

Что и как считаем

Идея простая. Если репозиторий долго не получает новых отправок коммитов (операций push), скорее всего, это заброшенный репозиторий GitHub. Такой подход позволяет оценить метрики заброшенности кода на массовых выборках. Способ не идеальный, т.к. бывают законченные проекты, которым обновляться незачем, бывают форки, в которые иногда ребейзят upstream и так далее. Наш подход работает скорее как массовый индикатор живости.

Взяты четыре порога заброшенности. Полгода, год, два года, пять лет с последней отправки. Для каждого языка и каждого порога посчитана доля репозиториев, попавших под него. Считается через стандартный фильтр Search API pushed:<DATE. Он возвращает только total_count, не выкачивая список репозиториев целиком. Подобный подход позволяет уложиться в лимиты с большим запасом.

Дополнительно для каждого языка собран топ-1000 репозиториев по звёздам с датами создания, последней отправки коммитов, размером и флагами archived и disabled. Это даёт срез по популярным проектам, тем, на которые реально полагаются другие разработчики. И отдельно выборка из разных страт по звездам, чтобы посмотреть зависимость заброшенности от популярности.

Точка отсчёта 14 мая 2026 года. Все доли посчитаны относительно этой даты.

Ограничения

Перед графиками стоит коротко обозначить рамки метода, подробный разбор слабых мест будет в конце статьи. Метрика опирается на флаг pushed_at, а это дата последней отправки в любую ветку, не обязательно в основную. Технически репозиторий может выглядеть живым из-за форков или ребейзов. Search API считает только публичные репозитории, поэтому корпоративная разработка в выборку не попадает. Архивированные репозитории из общей массы не вычитались, но они помечены отдельно, так что видно, кого закрыли явно, а кого молча оставили.

Ещё одно важное замечание. Это срез на сегодня, а не когортный анализ. Мы смотрим, какая доля всего существующего на языке выглядит живой, а не отслеживаем фиксированный набор репозиториев во времени. Отсюда смещение. У старых языков накоплен большой хвост легаси, у молодых его нет. Поэтому доли по всей массе нужно читать с поправкой на возраст экосистемы, а заброшенность среди топ-1000 по звёздам считается более чистым сигналом для оценки поддержки открытых проектов на GitHub. Дальше в статье для этого есть отдельный когортный разрез.

Результаты

Доля заброшенных публичных репозиториев по языкам

Доля заброшенных репозиториев на GitHub по языкам программирования, данные на май 2026. Источник: GitHub Search API, анализ популярности языков.

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

Выше всех по доле заброшенных оказался Ruby. 97,2 процента всех публичных Ruby-репозиториев без новых коммитов больше полугода, 95,3 процента больше года. Во многом это эффект возраста, ведь Ruby существует с 1995 года и накопил огромный хвост легаси. Что эта цифра значит на самом деле, видно только из когортного разреза ниже, и там картина для Ruby оказывается двойственной. Scala следом с 95,4 и 92,8 процента. Если читать буквально, на этих языках почти ничего не обновляется. У Swift, Elixir, Java цифры 85 процентов и выше. На другом конце шкалы Zig с 49,4 процента без новых коммитов больше года, TypeScript с 52,4, Lua с 60,5, Rust с 63, Python с 65,2.

Тут важно понимать, что эта картина производная не только от того, бросают код на языке или нет. Она зависит и от возраста экосистемы. Java существует с 1995 года, Ruby с 1995-го, поэтому накопленного легаси на этих языках много. У Rust первый стабильный релиз был в 2015 году, у Zig 1.0 пока нет. Цифры верные, но интерпретация «Ruby мёртв» из них напрямую не выводится. Скорее, на Ruby перестали активно создавать новое, а старого накопилось много.

Свежесть и архивирование

Доля свежих и архивированных репозиториев в топ-1000 по звёздам, анализ активности на GitHub

Здесь два сигнала на одном графике. Зеленые столбцы это доля проектов в топ-1000, созданных за последние два года. Красные доля заархивированных. Первое показывает приток новой крови среди популярных проектов, второе официальный выход из игры.

Zig впереди по обновлению. 33 процента его топ-1000 создано в 2024–2026 годах. Это много, экосистема буквально новая. У Python 19 процентов, у TypeScript 18, у Rust 13. У Scala доля свежих проектов в топ-1000 меньше 1 процента. За два года в звёздную тысячу Scala практически не вошло ни одного нового проекта. Сигнал надёжный, потому что выборка здесь это весь топ-1000, тысяча репозиториев. У Ruby и Java около 1 процента. Получается, что популярный топ Ruby и Scala это всё ещё те же проекты, что и пять лет назад.

По архивированным. У Scala 14,5 процента топа официально закрыто владельцами, у Ruby 10,2 процента, у JavaScript 9,5. У Rust 4,1, у TypeScript 3,3. Архивирование репозитория сильный сигнал. Владелец сознательно говорит, что дальше не поддерживает. Когда таких среди топа более 10 процентов, это уже про экосистему в целом.

Вся масса против популярных проектов

Сравнение заброшенности: все репозитории против популярных проектов на языках программирования

Это, наверное, самый показательный график во всей статье для понимания, как проверить активность репозитория на GitHub и отличить массовый «учебный шум» от реально поддерживаемых проектов. Красные столбцы доля заброшенных среди всех публичных репозиториев на языке. Синие среди топ-1000 по звездам. Чем больше разрыв между красным и синим, тем сильнее учебный мусор» искажает общую картину.

У JavaScript разрыв огромный. 77,7 процента всей массы мертво, но только 38,9 процента топа. Среди миллионов JS-репозиториев большинство это учебные материалы, домашние работы, экспериментальные форки.

У Python ещё чище. 65,2 процента против 19,3, то есть в массе Python выглядит хуже, чем в топе, потому что популярные Python-проекты активно поддерживаются, а массовая активность включает огромный хвост учебных проектов.

Swift и Scala интересны по-другому. У Swift 85,5 процента всей массы без новых коммитов больше года и 55,2 процента среди топ-1000, с доверительным интервалом от 52 до 58 процентов. Даже среди тысячи самых звёздных Swift-проектов заброшена больше половины, и это не шум выборки, интервал узкий. Похоже, экосистема не просто устарела массой, она проседает и в качественной части. У Scala 92,8 и 55,4. Картина аналогичная.

У Ruby двойственный сюжет. По всей массе 95,3 процента без новых коммитов больше года, а среди топ-1000 уже 39,4 процента, с интервалом от 36 до 42. Культовые Ruby-проекты живут, поддерживаются, а массовая разработка ушла. Язык сохраняет ядро серьёзных проектов, но потерял широкого пользователя.

Самые живые по обоим срезам TypeScript (52,4 и 10,6 процента) и Rust (63 и 12,5). У них и масса меньше мертва, и топ практически весь активен.

Контроль по возрасту, когортный разрез

Когортный анализ репозиториев по годам создания, метрики заброшенности кода

У графика "вся масса" есть слабое место: он смешивает здоровье языка программирования с возрастом экосистемы. Чтобы разделить эти факторы, мы применили когортный анализ репозиториев: группировку по году создания. Чтобы разделить эти факторы, мы сгруппировали топ-1000 каждого языка по году создания репозитория и для каждой годовой когорты посчитали долю заброшенных. Если бы вся разница между языками сводилась к накопленному легаси, при фиксированном годе создания все языки шли бы примерно вровень, но этого не происходит. В когорте 2015 года, где проекты ровесники и возраст уравнен полностью, TypeScript и Rust держатся около 18 процентов заброшенных, а Scala и Java уходят на 60 и выше. Разрыв сохраняется в каждой когорте с 2010 по 2022 год. Возраст экосистемы влияет на абсолютные цифры, и всё же он не объясняет разницу между языками. Java-проект 2016 года заброшен примерно втрое чаще, чем Rust-проект того же года.

Здесь нужны две оговорки. Когорты 2023 и 2024 годов у всех языков проседают почти к нулю. Эти репозитории слишком молодые, чтобы попасть под критерий "год без новых коммитов", так что провал в правой части графика это артефакт метрики, а не сигнал. Кроме того, Zig в график сознательно не включён. Ни в одной годовой когорте у него нет хотя бы 20 проектов, и линия тренда по таким данным была бы некорректной.

Заброшенность по стратам звезд

Заброшенность репозиториев по стратам звёзд: как популярность влияет на поддержку проекта

Здесь выборка построена иначе. Для каждого языка бралось по 100 репозиториев из четырёх страт по числу звезд, а именно меньше 10, от 10 до 100, от 100 до 1000 и больше 1000. Так получается более ровная картина, чем у топ-1000, где сильно выпирает популярная верхушка. У трёх языков верхняя страта неполная. У Zig 42 проекта с тысячей и более звёзд, у Julia 37, у R 89. Для этих трёх ячеек цифры приводятся, и всё же выводов по ним мы не делаем, выборка слишком мала. На карте видно, какая доля репозиториев в каждой страте больше года не получала новых коммитов. Зелёный значит живо, красный мертво.

Закономерность видна сразу. Чем больше звёзд, тем чаще проект живой. У большинства языков переход от страты 1–9 к страте 1000+ снижает заброшенность в 3–5 раз. В страте 1–9 у JavaScript, Ruby, Python, Dart, Scala 86–92 процента мёртвых. Это в основном учебные проекты, домашние работы, экспериментальные форки. Их жизненный цикл короткий по определению.

А вот страта 1000+ — это уже зеркало здоровья экосистемы языка и надёжный индикатор для тех, кто ищет, как выбрать надежную библиотеку на GitHub. И тут видно расслоение. У TypeScript всего 1 процент мёртвых среди проектов с тысячей и более звёзд, у Rust 3, у Python 6, у Go 7. То есть среди серьёзных проектов на этих языках почти ничего не бросают. Zig из этого ряда стоит исключить. В его верхней страте всего 42 проекта, и мёртв там формально один. При таком размере выборки честный доверительный интервал тянется от 0 до 12 процентов, поэтому вывод "у Zig почти ничего не бросают" по этим данным сделать нельзя.

В другом конце таблицы Dart с 32 процентами мёртвых в страте 1000+, Scala с 31, R с 27, Swift с 25, Java с 23, Lua с 23. Это значит, что даже популярные проекты на этих языках регулярно остаются без поддержки. Особенно показательны Scala и Swift. Если посмотреть вверх по таблице, у них и в страте 100–1000 заброшенность 45–68 процентов. Получается, что середина и верхняя середина экосистемы проседает.

Ruby в этой картине ведёт себя интересно. В страте 1000+ всего 13 процентов мёртвых, что лучше, чем у Java и C#. Культовые Ruby-проекты живут, но в страте 100–1000 уже 48 процентов мёртвых. То есть Ruby удерживает звёздную верхушку, но всё, что чуть ниже, постепенно умирает.

TypeScript показывает аномалию в страте 1–9. Всего 32 процента мёртвых, при том что у соседей по таблице 70–90. Это либо свидетельство того, что даже учебные TypeScript-проекты делают сравнительно недавно и они ещё не успели умереть, либо особенность аудитории. Можно предположить, что у TypeScript сейчас просто очень много свежих маленьких проектов, потому что язык активно осваивают новые разработчики.

Возрастной срез

Заброшенность репозиториев по возрасту: какой язык дольше поддерживается.

Тот же когортный разрез, теперь в разбивке по конкретным языкам и годам. Где в годовой когорте меньше 20 проектов, точка не строится, чтобы не выдавать шум за тренд.

Scala и Java стабильно держатся на 50–65 процентов заброшенных в когортах 2010–2018 годов. Проекты, начатые на этих языках в начале 2010-х, в массе своей сейчас не обновляются. У Rust и TypeScript когорты 2014–2018 годов всего 10–20 процентов мёртвых. Проекты тех же лет создания, но на этих языках, живут заметно лучше.

Это интересно с точки зрения вопроса, что из себя представляет современный язык в 2026 году. Дело, кажется, не только в том, что Rust и TypeScript популярны сейчас. Старые проекты на этих языках тоже держатся, потому что вокруг сформировалось сообщество, которое продолжает их поддерживать. У Scala и Java сообщество тоже большое, но, судя по цифрам, фрагментировано. Проекты остаются без тех, кто их сопровождает, и старый код просто перестают трогать.

Падение всех линий к 2024–2026 годам естественное. Эти репозитории слишком молодые, чтобы успеть умереть по выбранному критерию (год без новых коммитов).

Распределение по сроку последней отправки коммитов

Распределение репозиториев по времени последней отправки коммитов, статистика активности на GitHub

Шесть гистограмм по той же стратифицированной выборке. По оси X сколько лет прошло с последней отправки коммитов, по оси Y сколько репозиториев попало в этот интервал. Красная пунктирная линия порог в один год, зелёная это медиана. Здесь, в отличие от графика по топ-1000, видна картина по всей экосистеме, а не только по верхушке.

У TypeScript и Rust распределения похожи. Большой пик у нуля, 133–146 репозиториев из 400 в выборке (по 100 на страту) получали коммиты буквально на этой неделе. Дальше довольно толстый хвост на 1–8 лет. Медианы 0,36 и 0,3 года, то есть примерно 4 месяца. Заброшенность по выборке 37 и 35 процентов. Это значимо выше, чем 16 процентов на топ-1000, и это нормально. Стратифицированная выборка включает много маленьких проектов, которые забрасывают быстрее, чем популярные.

У Python ситуация уже заметно хуже. Пик у нуля поменьше (97 репозиториев), и хвост значительно толще. Медиана 2,02 года. Заброшено 62 процента выборки. То есть медианный Python-проект вне зависимости от популярности последний раз получал коммиты два года назад. С Python в массе всё сложнее, чем выглядит по топ-1000.

У Java, Ruby и Scala картина схожая, но более выраженная. Медианы 2,85, 2,2 и 2,62 года. Заброшено 67, 60 и 64 процента. Распределения почти равномерные после первого пика. То есть нормальная ситуация для этих языков, когда популярный проект не трогали год, два, три, пять лет.

Разница между этим графиком и тем, что был выше по топ-1000, важная. Топ-1000 это срез самых популярных проектов, и он показывает, что в верхушке у TypeScript и Rust почти все живы. Стратифицированная выборка добавляет к картине всё остальное и показывает, что у Python в массе средних проектов ситуация ближе к Java, чем к TypeScript. Оба среза верны, просто отвечают на разные вопросы. «Безопасно ли брать популярную библиотеку» и «как выглядит средний проект на этом языке».

Знаменитые покойники

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

• fighting41love/funNLP (Python, 80 тысяч звёзд) последняя отправка коммитов в мае 2024 года.
• MisterBooo/LeetCodeAnimation (Java, 76 тысяч) август 2023 года.
• resume/resume.github.com (JavaScript, 62 тысячи) февраль 2023 года.
• atom/atom (JavaScript, 60 тысяч, заархивирован) январь 2023 года. GitHub официально закрыл редактор Atom в пользу VS Code.
• angular/angular.js (JavaScript, 58 тысяч, заархивирован). Google прекратил поддержку AngularJS в начале 2022 года, репозиторий заморозили в 2024-м.
• astaxie/build-web-application-with-golang (Go, 43 тысячи). Образовательный проект, отправка коммитов в мае 2024 года.
• GitSquared/edex-ui (JavaScript, 44 тысячи, заархивирован). Терминал в стиле sci-fi, автор больше не поддерживает.
• adobe/brackets (JavaScript, 33 тысячи, заархивирован). Текстовый редактор от Adobe, закрыт после смены приоритетов компании.
• lllyasviel/ControlNet (Python, 33 тысячи). Модель для Stable Diffusion. Активность сместилась в форки и в более новые проекты автора.
• shadowsocks/shadowsocks (Python, 33 тысячи). Оригинальный репозиторий заморожен еще в 2024 году.

Среди этих покойников видно три типа смерти. Первый корпоративное решение. Atom и Brackets закрыты компаниями после смены стратегии. Второй естественное завершение. Проект достиг цели, автор пошёл дальше, как с edex-ui и hacker-scripts. Третий переезд активности в форки и новые проекты при сохранении звёзд на оригинале, как с ControlNet и shadowsocks. Это важный нюанс. Заброшенный репозиторий не всегда означает мертвую идею, иногда это просто перенос активности.

Выводы

TypeScript и Rust выглядят здоровее остальных. Среди топ-1000 по звёздам у TypeScript 10,6 процента заброшенных, у Rust 12,5 процента. Обе цифры опираются на тысячу репозиториев, и доверительные интервалы у них узкие. По стратифицированной выборке верхней страты получается 1 и 3 процента, и всё же там всего 100 проектов и интервалы широкие, поэтому надежная опора для вывода это именно топ-1000. На практике это значит, что когда разработчик ищет, как выбрать надежную библиотеку на GitHub, популярные зависимости на TypeScript или Rust имеют высокий шанс оставаться поддерживаемыми и это важный сигнал для выбора языка для нового проекта.

Если же смотреть не на верхушку, а на всю стратифицированную выборку, картина уже не такая радужная. Она включает по 100 проектов из каждой страты, в том числе мелкие репозитории с парой звёзд, и доля мёртвых там около 35 процентов у обоих языков. Противоречия с цифрой по топ-1000 здесь нет, просто это разные срезы. Тысяча звёздных проектов живёт почти вся, а средний по выборке проект забрасывают чаще. Для массовой экосистемы 35 процентов это обычный фон.

Ruby удерживает ядро, но теряет всё остальное. В страте 1000+ у Ruby всего 13 процентов заброшенных, заметная часть звёздного ядра жива, а вот средние и мелкие проекты массово забрасывают. Это типичная картина зрелого языка с уходящим поколением. Основа держится силами небольшой группы мейнтейнеров, нового притока нет.

По Scala все разрезы сходятся в одну сторону. 14,5 процента топ-1000 заархивировано, 55,4 процента топ-1000 без новых коммитов больше года с интервалом от 52 до 58, в когортах 2010 по 2018 заброшено от 55 до 66 процентов уже с контролем по возрасту, меньше 1 процента топа создано за последние два года. Каждый отдельный признак можно оспорить. Вместе они описывают экосистему, которая не пополняется новыми заметными проектами и теряет старые.

У Swift паттерн раздваивается. 85,5 процента всей массы мертво, что объяснимо. Много учебных iOS-проектов от начинающих, которые забросили после первой пробной сборки. Однако и среди популярных проектов в страте 1000+ 25 процентов мёртвых, что уже хуже среднего по таблице. Можно предположить, что дело в специфике мобильной разработки. Приложение выпустили, оно работает, репозиторий закрывают. Проверить такую версию по нашим данным нельзя, для этого нужен анализ типов проектов, а он выходит за рамки сбора. Так что это гипотеза, а не вывод.

Zig самая молодая и пока самая живая экосистема. Только 49 процентов всей массы мертво, языку 2 года, почти всё, что есть, создано относительно недавно. Это естественное преимущество молодости, и оно исчезнет, как только Zig накопит свой собственный легаси-хвост.

Парадокс топ-репозиториев. Чем популярнее проект, тем больше шанс, что он жив. Звучит банально, но важно. На большинстве языков переход из страты от 100 до 1000 в страту больше 1000 снижает заброшенность в 3–5 раз. Звёзды это не только индикатор популярности, но и индикатор живости. Что логично, т.к. проект, у которого много пользователей, получает сообщения об ошибках, форки и запросы на слияние, что заставляет владельца его поддерживать.

Оговорки

Метрика "не было отправок больше года" грубая по своей природе. Существуют законченные библиотеки, которым обновляться попросту незачем, вроде маленьких утилит типа is-even в npm. Существуют спецификации и учебные репозитории, которые по определению не должны меняться. В нашей метрике все они засчитываются как заброшенные, хотя по сути живы, и без ручного разбора каждого репозитория от этого не уйти.

Архивированные репозитории не вычитались из общей массы. Если бы вычитались, цифры по Scala и Ruby стали бы чуть лучше, но не радикально, доля архивированных в общей массе невелика.

GitHub это не весь мир разработки. Корпоративный код на Java и C# во многом живет в GitLab, Bitbucket и внутренних установках, а китайская сцена прочно сидит на Gitee. Поэтому фраза "84 процента публичных Java-репозиториев заброшено" верна только для публичной активности на GitHub и не отражает жизненный цикл программного проекта в корпоративных репозиториях на GitLab или Bitbucket. В реальном использовании Java остаётся активной в десятках тысяч корпораций, которые свой код наружу не выкладывают.

Отдельно про доверие к цифрам. Показатели по топ-1000 и по всей массе опираются на большие выборки, доверительные интервалы у них узкие, и на эти выводы можно полагаться. Показатели по стратифицированной выборке, где сто репозиториев на страту, надежны для сравнения порядка величин, но не для десятых долей процента, а три верхние страты, у Zig, Julia и R, неполные, и выводов по ним мы не делаем. Когортный разрез уравнивает возраст проектов, но не уравнивает их тип. Библиотека, приложение и учебный репозиторий живут по-разному, и в наших данных это не разделено.