Мобилка

История Java, Android и Kotlin

Прочитано0%

Квизы0/5

Тренажёрыне пройден0/1

Уровень 1 · Новичок

Зачем это нужно

Каждое странное правило в языке когда-то было чьим-то решением. open перед классом, companion object вместо static, знак вопроса у типа, само существование двух языков в одном проекте — всё это не капризы, а следы конкретных событий: судебного иска, сделки по покупке компании, доклада на конференции, ограничений телефона 2008 года.

Знать эту цепочку полезно по трём причинам.

Первая — читать чужой код. В любом Android-проекте старше пары лет лежит Java. Не «где-то в легаси», а прямо в соседнем файле. Понимать, откуда она там и почему её не переписали, — часть работы.

Вторая — понимать сообщения об ошибках. Половина странных слов в них — NullPointerException, ClassCastException, «bytecode», «JVM target 1.8» — родом из Java, а не из Kotlin. Не зная слоёв, невозможно понять, кто именно ругается.

Третья — отвечать на собеседовании и на защите проекта. Вопрос «почему Kotlin, а не Java?» задают почти всегда. Ответ «он современнее» звучит как «не знаю». Ответ с датами, причинами и конкретной выгодой — как ответ человека, который разбирается.

Даты в этой главе сверены с официальными страницами: список релизов Kotlin и FAQ на kotlinlang.org. Где событие известно по докладу или пресс-релизу, это сказано прямо.

• Зачем это нужно
• 1991: холодильник, которому нужен был язык
• Что такое JVM и почему это важно до сих пор
• 2003–2008: как появился Android
• Путь кода от файла до экрана
• 2010: два события, определившие всё дальнейшее
• 2010–2016: как появился Kotlin
• 2017 и 2019: два объявления Google
• 2021: Compose, который бывает только на Kotlin
• Два языка в одном проекте
• Kotlin сегодня: 2.0, K2 и версия 2.4
• Куда ещё компилируется Kotlin
• Что стало с самой Java
• Пять мифов
• Тренажёр: слова и даты
• Даты одним списком
• Что должен уметь
• Куда дальше: проверенные ресурсы

1991: холодильник, которому нужен был язык

История начинается не с телефонов и даже не с интернета, а с бытовой техники.

В 1991 году в компании Sun Microsystems команда во главе с Джеймсом Гослингом работала над проектом для «умных» бытовых устройств: телевизионных приставок, пультов, будущей интерактивной кабельной сети. Задача выглядела так: устройств много, процессоры у всех разные, а программу хочется писать одну.

Существовавшие языки не подходили. Программа на C компилировалась под конкретный процессор: собрал под один — под другой не работает. Переписывать под каждую железку — ад.

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

Язык сначала назвали Oak — по дубу за окном офиса Гослинга. Имя оказалось занято, и в 1995 году язык вышел под названием Java — по сорту кофе, названному, в свою очередь, по индонезийскому острову Ява.

Проект для бытовой техники не взлетел. Зато ровно в это время появился веб, и идея «одна программа работает везде» попала точно в момент. Лозунг «Write once, run anywhere» — «напиши один раз, запускай где угодно» — стал самым известным рекламным обещанием в истории программирования.

Тридцать лет на одной ленте. Обрати внимание на разрыв между 2008 и 2017 годом: девять лет Android жил на языке, который к тому моменту уже считался устаревшим.

Что такое JVM и почему это важно до сих пор

Виртуальная машина Java — JVM — это программа, которая делает вид, что она процессор. Она читает байт-код и превращает его в настоящие команды того процессора, на котором запущена.

Отсюда всё остальное:

• Переносимость. Один и тот же файл .class работает на Windows, Linux, macOS — везде, где есть JVM.
• Сборка мусора. Память освобождает машина, а не программист. Целый класс ошибок с «висячими указателями» из C и C++ исчез.
• Проверки при загрузке. JVM проверяет байт-код перед исполнением, поэтому испорченный файл не уронит систему.
• Скорость не как у интерпретатора. JVM следит, какие куски кода выполняются часто, и на ходу компилирует их в машинный код. Это называется JIT — компиляция «прямо во время работы».

И главное для нас: JVM исполняет байт-код, а не исходник. Ей всё равно, на каком языке этот байт-код написали. Именно эта деталь тридцать лет спустя позволит Kotlin появиться и мгновенно получить всю экосистему Java целиком.

✨Интересный факт

Kotlin — далеко не первый язык, воспользовавшийся этой лазейкой. До него на JVM жили Groovy, Scala, Clojure, JRuby. Но именно Kotlin оказался в нужном месте: он делал ровно ту работу, что и Java, только короче, и не требовал менять образ мышления. Scala предлагала другой стиль программирования целиком — и осталась языком для тех, кто этого хотел.

2003–2008: как появился Android

Компанию Android Inc. основали в 2003 году; самым известным из основателей стал Энди Рубин. Изначально они делали операционную систему для фотоаппаратов, но быстро переключились на телефоны.

В 2005 году компанию купил Google. Тогда это выглядело малозначительной покупкой — до iPhone оставалось ещё два года.

Android 1.0 вышел в сентябре 2008 года, первым устройством стал HTC Dream (в США он продавался как T-Mobile G1) — телефон с выдвижной физической клавиатурой. Языком для приложений стала Java: она была самым распространённым языком в мире, под неё существовала гора библиотек, и на ней уже умели писать миллионы людей.

Но Google взял язык Java, а не виртуальную машину Java. Разница принципиальная, и объясняется она двумя причинами.

Юридическая. JVM принадлежала Sun и распространялась на условиях, которые Google не устраивали. Своя виртуальная машина снимала вопрос лицензии — как тогда казалось.

Техническая. Телефон 2008 года имел меньше памяти, чем сегодня её у наручных часов. JVM была рассчитана на серверы, и для телефона её сделали заново, под другие ограничения.

Так появился Dalvik — виртуальная машина Android, названная, по словам её автора Дэна Борнстайна, в честь рыбацкой деревни в Исландии, откуда происходили его предки. Dalvik исполнял не .class, а свой формат — DEX, в который все классы приложения складывались одним файлом, компактнее и с другой внутренней организацией.

Путь кода от файла до экрана

Эта цепочка не изменилась с тех пор — поменялись только инструменты внутри неё:

Оба языка сходятся в одной точке — в байт-коде JVM. Ровно поэтому Kotlin работает на Android без всякого переходника, а Java-библиотеки доступны из Kotlin напрямую.

1. Компилятор (kotlinc или javac) превращает исходник в байт-код JVM.
2. Инструмент D8 переводит байт-код в DEX, а R8 заодно выбрасывает неиспользуемый код и сокращает имена — это то самое «уменьшение размера приложения», о котором говорят на сборке релиза.
3. DEX попадает внутрь файла .apk — по сути обычного архива.
4. На телефоне DEX исполняет ART — Android Runtime.

ART заменил Dalvik: он появился как необязательная опция в Android 4.4 (2013) и стал стандартом в Android 5.0 (2014). Главное отличие — компиляция части кода заранее, при установке, а не при каждом запуске. Позже подход стал смешанным: часть кода компилируется на ходу, часть — заранее, по накопленным данным о том, чем пользователь пользуется чаще.

Практический вывод для тебя один и очень конкретный: на Android Kotlin и Java абсолютно равноправны, потому что до D8 добирается одинаковый байт-код. Никакого «переходника» между языками нет — переходить не через что.

Отвечено вопросов: 0 из 4

Для чего изначально придумывали Java в 1991 году?

В чём главная идея виртуальной машины?

Почему Android взял язык Java, но не виртуальную машину Java?

Что исполняет код на современном Android?

Отвечено верно: 0 из 4

2010: два события, определившие всё дальнейшее

Год оказался решающим сразу дважды.

Oracle купил Sun. Сделку объявили в 2009-м и завершили в начале 2010-го. Java сменила владельца: у неё появилась компания, гораздо активнее защищающая свои права.

Oracle подал в суд на Google. Иск, поданный в 2010 году, касался использования в Android интерфейсов Java — не самого кода, а описаний того, как классы и методы называются и что принимают. Процесс шёл более десяти лет, дошёл до Верховного суда США, и в апреле 2021 года решение вынесли в пользу Google: такое использование признали добросовестным.

Для нас важен не итог, а десятилетие неопределённости между иском и решением. Пока шёл процесс, Android было очень неуютно развивать поддержку Java. Новые версии языка выходили — Java 8 в 2014 году принесла лямбды, — а Android оставался на возможностях старых версий. Разработчики писали на языке, который в остальном мире считался устаревшим, и обходились без вещей, ставших нормой везде.

Именно в этот зазор и вошёл Kotlin.

Отвечено вопросов: 0 из 4

Из-за чего судились Oracle и Google?

Чем этот процесс обернулся для Android-разработчиков?

Что принесла Java 8, вышедшая в 2014 году?

Кому принадлежит Java с 2010 года?

Отвечено верно: 0 из 4

2010–2016: как появился Kotlin

Компания JetBrains делает инструменты для программистов: IntelliJ IDEA, PyCharm, WebStorm — и, вместе с Google, Android Studio. То есть компанию, у которой миллионы строк собственного Java-кода и которая лучше всех в мире знает, как этот код мучительно писать.

По официальному FAQ на kotlinlang.org проект начался в 2010 году. Публично язык показали в июле 2011-го, а в феврале 2012-го исходники открыли под лицензией Apache 2.0.

Имя язык получил по острову Котлин в Финском заливе, рядом с которым находится офис JetBrains в Санкт-Петербурге. Выбор не случайный: Java тоже названа по острову.

Задача формулировалась предельно приземлённо. Не «сделать идеальный язык», а: писать то же, что на Java, но короче и безопаснее; работать со всем существующим Java-кодом без переделок; компилироваться быстро; иметь отличную поддержку в редакторе — что для JetBrains было делом чести.

Kotlin 1.0 вышел в феврале 2016 года. Главным в этом релизе была не какая-то возможность, а обещание: язык объявлен стабильным, дальше — обратная совместимость. Код, написанный сегодня, будет собираться завтра.

⚠️Важно

Kotlin придумали не в Google. Это распространённое заблуждение. Google язык не создавал, а поддержал — через пять лет после его появления и через год после версии 1.0. Автор языка — компания JetBrains, а первым руководителем проекта был Андрей Бреслав. Знать это стоит: вопрос «а кто вообще сделал Kotlin» на собеседовании звучит регулярно.

2017 и 2019: два объявления Google

Май 2017, конференция Google I/O. Google объявляет Kotlin официально поддерживаемым языком для Android. Поддержка встроена в Android Studio, никаких плагинов ставить не надо.

Реакция зала на записи трансляции — овация. Причина понятна: сообщество уже несколько лет писало на Kotlin неофициально, на свой страх и риск, и главным аргументом против была фраза «а вдруг Google это не поддержит».

Май 2019, снова Google I/O. Объявлен принцип Kotlin-first: новые библиотеки, примеры и документация Android делаются в первую очередь для Kotlin, а Java-версия — уже потом, если вообще. Формулировка со сцены звучала прямо: разработку новых приложений рекомендуется начинать на Kotlin.

Между этими двумя объявлениями, в 2018 году, JetBrains и Google основали Kotlin Foundation — организацию, которая отвечает за развитие языка и гарантирует, что он не окажется в собственности одной компании.

А потом произошло то, что сделало вопрос выбора языка окончательно неактуальным.

2021: Compose, который бывает только на Kotlin

Jetpack Compose 1.0 вышел в июле 2021 года — новый способ делать интерфейсы Android, тот самый, что разбирается в главе «Первый экран Compose».

Ключевое: Compose существует только для Kotlin. Не «на Kotlin удобнее» — а из Java его использовать нельзя вовсе. Он построен на возможностях, которых в Java просто нет: функции с аннотацией @Composable, лямбды-с-получателем, корутины для состояния.

Это изменило смысл выбора. До 2021 года Kotlin был приятной альтернативой. После — стал условием доступа к основному инструменту платформы. Спор «Java или Kotlin» на Android закончился не победой в дискуссии, а тем, что новые инструменты стали выходить только на одном языке.

Два языка в одном проекте

Совместимость — не рекламный тезис, а то, с чем сталкиваешься в первый же день на живом проекте.

Файлы двух языков лежат рядом в одном модуле и вызывают друг друга напрямую. Именно поэтому переход на Kotlin шёл не «переписыванием проекта», а по одному файлу за раз.

Как это устроено:

• Kotlin видит Java. Любой Java-класс из любой библиотеки используется напрямую: import, создание объекта, вызов метода. Никаких обёрток.
• Java видит Kotlin. Свойство val owner компилируется в приватное поле с методом getOwner() — обычный Java-класс, каким его и ожидает увидеть Java-код.
• Оба компилируются вместе. Gradle собирает и .kt, и .java в одном модуле, получая общий байт-код.
• Есть конвертер. В Android Studio достаточно вставить Java-код в .kt-файл, и редактор предложит перевести его в Kotlin. Перевод не всегда идеален, но восемьдесят процентов работы делает.

Отсюда — стратегия, которой пользовались все: новые файлы пишутся на Kotlin, старые переводятся по мере необходимости. Ни один большой проект не переписывали целиком, и не надо было.

Есть и обратная сторона, о которой стоит знать заранее: типы из Java приходят в Kotlin без гарантий на null. Компилятор Java ничего не знает про nullable-типы, поэтому строка из Java-библиотеки для Kotlin — это «платформенный тип», который язык обозначает как String!. Проверок он не требует, но и не защищает: NullPointerException из такого места вполне возможен. Практическое правило — значения, пришедшие из Java-кода, проверять руками.

Отвечено вопросов: 0 из 4

Кто создал Kotlin?

Что произошло на Google I/O в мае 2017 года?

Почему Jetpack Compose окончательно закрыл спор о выборе языка?

Что такое платформенный тип String! из Java-кода?

Отвечено верно: 0 из 4

Kotlin сегодня: 2.0, K2 и версия 2.4

Kotlin 2.0.0 вышел 21 мая 2024 года. Главное в нём — K2, полностью переписанный компилятор. Для языка почти ничего не изменилось: тот же синтаксис, тот же код. Изменилось то, как компилятор понимает программу внутри: он стал заметно быстрее и научился точнее выводить типы, из-за чего часть старых предупреждений исчезла, а часть новых появилась.

Дальше язык живёт по расписанию: большая версия раз в полгода, между ними — обновления инструментов и исправления. По официальной странице релизов:

Версия	Дата
Kotlin 1.0	февраль 2016
Kotlin 2.0.0	21 мая 2024
Kotlin 2.1.0	27 ноября 2024
Kotlin 2.2.0	23 июня 2025
Kotlin 2.3.0	16 декабря 2025
Kotlin 2.4.0	3 июня 2026
Kotlin 2.4.10	14 июля 2026

Kotlin 2.4.10 — та самая версия, которая запускает примеры на этой платформе. Все выводы и все сообщения об ошибках в главах про Kotlin получены именно от неё.

Полезная привычка, которая пригодится и на чемпионате, и на работе: проверять номер версии, прежде чем спорить о поведении языка. Половина противоречивых ответов в интернете — про разные версии.

Куда ещё компилируется Kotlin

Kotlin давно перестал быть «языком для JVM».

Один язык, четыре цели компиляции. Для мобильной разработки главная — первая, но именно из-за остальных Kotlin используют и там, где никакого Android нет.

• JVM — Android и серверные приложения. Здесь Kotlin начинался и здесь его больше всего.
• Native — компиляция сразу в машинный код, без виртуальной машины. Отсюда работа на iOS.
• JS — код для браузера и Node.js.
• Wasm — WebAssembly, современный способ выполнять быстрый код в браузере.

На этом построена Kotlin Multiplatform: бизнес-логику — работу с сетью, хранение, расчёты — пишут один раз и используют и в Android-, и в iOS-приложении, а экраны делают на каждой платформе своими средствами. Для команды из двух человек это разница между «поддерживаем два приложения» и «поддерживаем одно с двумя лицами».

Пока это знать полезно, а применять рано: в этом треке мы делаем обычное Android-приложение на JVM. Но когда услышишь «KMP» — это про то, что выше.

Отвечено вопросов: 0 из 4

Что главное принесла версия Kotlin 2.0 в мае 2024 года?

Как часто выходят большие версии Kotlin?

Куда, кроме JVM, компилируется Kotlin?

На какой версии Kotlin запускаются примеры этой платформы?

Отвечено верно: 0 из 4

Что стало с самой Java

Java не исчезла и никуда не денется. Более того, последние десять лет она развивается быстрее, чем предыдущие пятнадцать: релизы выходят каждые полгода, версии с долгой поддержкой — раз в два года.

Что важно знать про её путь:

• Java 8, 2014 — лямбды и потоки данных. Самый значимый релиз в истории языка; именно его отсутствие на Android так долго ощущалось.
• OpenJDK — Java открыта, и её свободные сборки бесплатны.
• record, Java 16, 2021 — прямой аналог data class, только жёстче: поля всегда неизменяемы, наследование запрещено, аналога copy() нет.
• sealed, Java 17, 2021 — закрытые иерархии, знакомые по прошлой главе.
• Виртуальные потоки, Java 21, 2023 — ответ на ту же задачу, которую в Kotlin решают корутины.

Видна закономерность: Java идёт в ту же сторону, что и Kotlin, только медленнее и осторожнее. Причина не в лени, а в масштабе: на Java написан банковский и промышленный код, который должен собираться и через двадцать лет. Такой груз не позволяет менять язык быстро.

Пять мифов

«Kotlin — это надстройка над Java». Нет. Это отдельный язык со своим компилятором и своей стандартной библиотекой. Общая точка ровно одна — байт-код на выходе.

«Kotlin медленнее, потому что он поверх Java». На выходе тот же байт-код и та же виртуальная машина, так что разницы в скорости работы приложения практически нет. Дольше идёт сборка: компилятору Kotlin надо сделать больше работы. Это про ожидание разработчика, а не про скорость у пользователя.

«Java на Android умерла». Огромная часть Android SDK написана на Java, и Kotlin вызывает её напрямую в каждом приложении. Java перестала быть языком, на котором пишут новое, но осталась языком, который читают каждый день.

«Kotlin придумали в Google». JetBrains. Google лишь поддержал его в 2017 году.

«Раз есть Kotlin, Java учить не надо». Учить как основной — не надо. Уметь читать — обязательно: половина ответов на вопросы по Android, куски документации и целые библиотеки будут на Java. Именно поэтому в этом треке есть отдельная глава «Kotlin и Java: в чём разница».

💡Совет

Если на защите проекта спросят «почему Kotlin?» — не отвечай «он современнее». Ответь по делу: null-безопасность на уровне компилятора убирает самый частый вид падений Android-приложений; data class и sealed class сокращают код в разы; Jetpack Compose доступен только из Kotlin; Google объявил язык приоритетным ещё в 2019 году. Четыре факта вместо одного эпитета — и разговор идёт совсем иначе.

Тренажёр: слова и даты

Цель: скорость ≥ 100 зн/мин, точность ≥ 88%

Java 1.0 — 1995, Sun Microsystems

следующая: J — указательный правой руки (+ Shift)

Даты одним списком

Год	Событие	Почему важно
1991	Sun начинает проект Oak	появляется идея байт-кода и виртуальной машины
1995	выходит Java 1.0	«напиши один раз — запускай где угодно»
2003	основана Android Inc.	сначала — система для фотоаппаратов
2005	Google покупает Android Inc.	за два года до iPhone
2008	Android 1.0, HTC Dream	язык приложений — Java, машина — Dalvik
2010	Oracle покупает Sun и подаёт в суд на Google	десятилетие неопределённости вокруг Java на Android
2010	JetBrains начинает проект Kotlin	по официальному FAQ языка
2011	Kotlin показан публично	июль
2012	исходники открыты под Apache 2.0	язык становится свободным
2013–2014	ART заменяет Dalvik	стандарт с Android 5.0
2014	Java 8: лямбды и потоки	на Android они появятся сильно позже
2016	Kotlin 1.0, февраль	обещание обратной совместимости
2017	Google I/O: официальная поддержка	Kotlin встроен в Android Studio
2018	создан Kotlin Foundation	JetBrains и Google вместе
2019	Google I/O: Kotlin-first	новое делается сначала для Kotlin
2021	Jetpack Compose 1.0, июль	интерфейсы только на Kotlin
2021	Верховный суд США решает спор в пользу Google	апрель
2024	Kotlin 2.0 с компилятором K2	21 мая
2026	Kotlin 2.4.10	14 июля; на ней работают примеры этой платформы

Что должен уметь

• Объяснять, зачем придумали байт-код и виртуальную машину.
• Рассказывать, откуда взялись названия Java и Kotlin.
• Объяснять, почему на JVM смог появиться другой язык.
• Называть год выхода Android и язык, на котором писали первые приложения.
• Объяснять, почему Android взял язык Java, но не JVM.
• Описывать путь кода: исходник → байт-код → DEX → ART.
• Объяснять роль D8 и R8 при сборке приложения.
• Знать, что ART заменил Dalvik и когда это произошло.
• Рассказывать, кто создал Kotlin и в каком году.
• Называть дату выхода Kotlin 1.0 и объяснять, что именно она означала.
• Различать два объявления Google: 2017 и 2019.
• Объяснять, почему Jetpack Compose закрыл спор о выборе языка.
• Объяснять, как Java и Kotlin уживаются в одном модуле.
• Понимать, что такое платформенный тип String! и чем он опасен.
• Знать, что принесла версия 2.0 и что такое K2.
• Называть четыре цели компиляции Kotlin.
• Объяснять, зачем нужна Kotlin Multiplatform.
• Опровергать пять распространённых мифов о Kotlin.
• Отвечать на вопрос «почему Kotlin, а не Java» четырьмя конкретными фактами.

Углубиться

Из-за чего был спор Oracle и Google. Судились не из-за кода, а из-за интерфейсов — списка того, как называются классы и методы и что они принимают. Google написал свою реализацию, но сохранил названия, чтобы Java-программисты могли писать под Android без переучивания. Вопрос стоял так: охраняется ли авторским правом сама структура имён. Ответ Верховного суда США в апреле 2021 года был осторожным: такое использование признали добросовестным в этих обстоятельствах. Для отрасли это ключевое решение — от него зависит, можно ли повторять чужой интерфейс, оставаясь в законе.

Почему Dalvik был регистровым. JVM — стековая машина: значения кладутся на стек, команда снимает их оттуда. Dalvik сделали регистровым — как настоящий процессор. Команд получается меньше, а каждая — крупнее; для медленной памяти телефона 2008 года это было выгоднее. Сегодня разница неактуальна, но формат DEX остался и живёт в каждом приложении.

Что на самом деле изменил K2. Прежний компилятор строил дерево программы, а потом дописывал в него сведения о типах — из-за чего каждый новый анализ приходилось встраивать в довольно запутанное место. K2 отделил разбор от анализа: сначала строится дерево, потом отдельно — «разрешённое» представление со всеми типами. Это ускорило компиляцию и упростило добавление проверок. Побочный эффект, о который спотыкались при переходе, — часть кода, раньше проходившая по недосмотру старого компилятора, перестала собираться.

Почему в Kotlin нет static. Не из вредности. static-члены в Java живут вне объектной системы: их нельзя переопределить, они не участвуют в наследовании, их неудобно подменять в тестах. companion object — обычный объект: у него есть тип, он может реализовать интерфейс, его можно передать как значение. Цена — чуть более длинная запись и дополнительный класс в байт-коде.

Что такое @JvmStatic и зачем оно. Когда Kotlin-код зовут из Java, companion object виден как поле Companion, и вызов выглядит громоздко: User.Companion.of(...). Аннотация @JvmStatic просит компилятор сгенерировать ещё и настоящий статический метод, чтобы из Java писалось User.of(...). Целое семейство таких аннотаций — @JvmName, @JvmOverloads, @JvmField — существует ровно для того, чтобы Kotlin-код удобно смотрелся со стороны Java.

Дальше по теме:

• Kotlin FAQ — официальные ответы про происхождение и назначение языка
• Kotlin releases — полный список версий с датами
• Android Developers: Kotlin overview — позиция Google по языку
• Android Developers: Java 8+ API desugaring — как на Android появились возможности новых версий Java
• Kotlin Multiplatform — про общий код для нескольких платформ

Сводная проверка по всей главе: 16 вопросов, 5:00 на всё, без подсказок по ходу. Вопросы показываются по одному, ответ изменить нельзя. Если время выйдет — экзамен завершится с тем, что успел ответить. Пересдавать можно сколько угодно раз.

Куда дальше: проверенные ресурсы

• Kotlin FAQ — год начала проекта, дата версии 1.0, назначение языка.

• Kotlin releases — полный список версий с точными датами.

• Kotlin Foundation — кто и как управляет развитием языка.

• Android Developers: Kotlin — официальная позиция Google и материалы для перехода.

• Android Developers: Jetpack Compose — тот самый инструмент, который бывает только на Kotlin.

• Android Developers: Java 8+ API desugaring — как на Android появились возможности новых версий Java.

• Kotlin Multiplatform — общий код для JVM, Native, JS и Wasm.

• OpenJDK — открытая реализация Java и её история релизов.

• Видео и материалы сообщества — ниже — ролики по теме и ссылки от студентов и преподавателей смотри в самом низу страницы.