Kotlin разработка под windows

Уровень сложностиСредний

Время на прочтение10 мин

Количество просмотров5.9K

English version

В этой статье я хочу рассказать о практическом опыте нативной компиляции production приложения, написанного на Kotlin со Spring Boot, Gradle с использованием GraalVM . Начну сразу с минусов и плюсов самой возможности нативной компиляции и где она может быть полезна, и дальше перейду уже непосредственно к процессу сборки под MacOS и Windows.

В конце статьи я более подробно расскажу о проекте и почему возникла такая необходимость, учитывая довольно много ограничений и подводных камней поддержки нативной компиляции как со стороны Spring Boot, та и со стороны GraalVM.

1. О минусах и где не будет смысла использовать

• Требуются большие ресурсы и довольно много времени на компиляцию.

• Требуется рассказать GraalVM о всех прокси классах и вообще всей рефлексии в проекте, чтобы компилятор случайно не выкинул какой-нибудь класс или метод потому что не смог до него достучаться.

• Из предыдущего пункта следует, что для интеграции с CI нужно очень большое покрытие тестами, чтобы не пропустить какой-нибудь код (врядли кто-то захочет все вручную описывать в конфиг файлах GraalVM).

• В continuous delivery я не увидел особого смысла, т.к. для сборки требуются довольно большие ресурсы от которых сильно зависит время компиляции, которое может достигать 15-30 минут для не очень больших приложений, при этом может требоваться минимум 8-10 Гб оперативки и ядер побольше. Из плюсов только очень быстрое время старта — мое среднеее по размерам приложение стартует за 0.5 секунды, а с JVM — около 5-10 секунд. Это может позволить очень быстро разворачивать кластер, например, в k8s (ну и если под упал, то рестартанет он очень быстро).

• Возможно еще в каких-то случаях не будет смысла использовать из-за предыдущих ограничений и требований.

2. Где может очень пригодиться?

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

Плюсы для десктопа довольно очевидны в сравнении с JVM:

• Маленький размер исходного бинаря важно при распространении приложения для клиентов — в моем случае стандартный *.jar вместе с JDK получался размером примерно в 300-400Мб, нативный бинарь — 190Мб (MacOS)

• Не требуется JDK и добавлять всякие хитрости вроде скачивания самой JDK в фоне при установке, чтобы показать клиентам маленький размер исходного *.jar файла

• Код защищен от копирования — по крайней мере гораздо сложнее воспроизвести по сравнению с обычным *.jar-ником даже после прогона через ProGuard

• Очень быстрый старт почти как у низкоуровневых языков (C++ и подобных)

Последний пункт играет особенно большую роль, т.к. если пользователь может потратить 1 раз время на скачивание жирного приложения, то вот часто запускать его и ждать по 10-20 секунд такое себе.

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

3. Предисловие

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

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

Исходники тестового приложения находятся в репозитории.

Что входит в скелетон приложения:

• Websockets

• Jackson (Object Mapper)

• Caffeine Cache

• SQLite

• Mapstruct

• Flyway

• Kotlin Coroutines

• Logstash Logback (для логирования в JSON для систем сбора и хранения логов)

• Всякие Junit 5, Kotest и прочие тестовые библиотеки (хотя сами тесты я не добавлял)

4. Некоторые тонкости сборки нативного приложения

Немного хочу остановиться на том, что требуется для успешной компиляции и где сохранять конфиги для GraalVM.

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

Сами конфиги сохраняются в каталоге: /resources/META-INF/native-image.

Запустить агента можно следующей командой:

graalvm-jdk-17/Contents/Home/bin/./java -Dspring.aot.enabled=true -agentlib:native-image-agent=config-merge-dir=./src/main/resources/META-INF/native-image -jar build/libs/native-app-1.0.0.jar

Здесь важна конструкция:

-agentlib:native-image-agent=config-merge-dir

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

5. Инструментарий — установка и настройка

Я собираю приложение сразу под MacOS и Windows, и опишу как это сделать, особенно есть нюансы под Windows.

Версия JDK 17 и GraalVM так же под эту версию. (Версию 20 я не пробовал).

Далее в Gradle нужно добавить зависимости для сборки native (приведу в примере только необходимые зависимости, весь файл можно посмотреть в примере на github):

Общие настройки build.gradle.kts для всех платформ:

build.gradle.kts

val nativeImageConfigPath = "$projectDir/src/main/resources/META-INF/native-image"
val nativeImageAccessFilterConfigPath = "./src/test/resources/native/access-filter.json"

plugins {
    val buildToolsNativeVersion = "0.9.21"

    id("org.graalvm.buildtools.native") version buildToolsNativeVersion
}

repositories {
    mavenCentral()
    maven { url = uri("https://repo.spring.io/milestone") }
    mavenLocal()
}

graalvmNative {
    binaries {
        named("main") {
            buildArgs(
                "-H:+ReportExceptionStackTraces",
                "-H:EnableURLProtocols=http,https",
            )
        }
    }
}

buildscript {
    repositories {
        maven {
            setUrl("https://plugins.gradle.org/m2/")
        }
    }
}

tasks.withType<Test> {
    jvmArgs = listOf(
        "-agentlib:native-image-agent=access-filter-file=$nativeImageAccessFilterConfigPath,config-merge-dir=$nativeImageConfigPath"
    )
}

Дополнительно нужно обновить урлы репозиториев pluginManagement в файле settings.gradle.kts:

settings.gradle.kts

pluginManagement {
    repositories {
        maven { url = uri("https://repo.spring.io/milestone") }
        maven { url = uri("https://repo.spring.io/snapshot") }
        gradlePluginPortal()
    }
}

И в каталоге с тестами: /test/resources/native/access-filter.json добавить файл фильтра лишних классов из кофнига метаинформации после запуска тестов.

/test/resources/native/access-filter.json

{ "rules": [
  {"excludeClasses": "com.gradle.**"},
  {"excludeClasses": "sun.instrument.**"},
  {"excludeClasses": "com.sun.tools.**"},
  {"excludeClasses": "worker.org.gradle.**"},
  {"excludeClasses": "org.gradle.**"},
  {"excludeClasses": "com.ninjasquad.**"},
  {"excludeClasses": "org.springframework.test.**"},
  {"excludeClasses": "org.springframework.boot.test.**"},
  {"excludeClasses": "org.junit.**"},
  {"excludeClasses": "org.mockito.**"},
  {"excludeClasses": "org.opentest4j.**"},
  {"excludeClasses": "io.kotest.**"},
  {"excludeClasses": "io.mockk.**"},
  {"excludeClasses": "net.bytebuddy.**"},
  {"excludeClasses": "jdk.internal.**"},
],
  "regexRules": [

  ]
}

Особенно из запуска агента из тестов мне доставлял проблем при компиляции пакет: jdk.internal.**. После добавления в фильтр проблемы пропали.

При необходимости можно добавлять сюда свои пакеты/классы, которые необходимо исключить из компиляции. Подробнее про это можно найти в документации GraalVM.

5.1 MacOS

Скачиваем для начала архив с GraalVM для MacOS и версии Java 17 с оф. сайта: GraalVM Downloads

Распаковываем в удобное место и прописываем env переменную:

export JAVA_HOME=<path-to-graalvm-jdk-17/Contents/Home>

source ~/.zshrc

На этом настройка завершена, можно в Intellij Idea выбрать GraalVM в настройках проекта и запускать сборку.

5.2 Windows

Сборку я производил на виртуалке VMware с Windows 10.

5.2.1 Сначала о проблемах и ограничениях

Здесь все оказалось чуть сложнее. Сложности возникли из-за ограничений Windows на длину пути к файлу для зависимостей maven’a (issue). Решением оказалось перенести каталог с зависимостями в самый короткий путь, для меня в C:\m2.

5.2.2 Инструментарий

Скачиваем для начала архив с GraalVM для Windows и версии Java 17 с оф. сайта: GraalVM Downloads

Вообще на сайте GraalVM есть подробный туториал для установки под Windows: Install GraalVM on Windows. Рекомендую следовать ему, т.к. там требуется еще установка Visual Studio Build Tools and Windows SDK.

Устанавливаем Gradle для Windows по туториалу с оф. сайта: Gradle on Windows в разделе Installing manually. Не буду здесь повторяться.

В итоге должны быть правильно прописаны env переменные с путями до gradle и java (можно проверить версии через консоль) и правильно установлен Visual Studio Build Tools.

Важно сборку производить в правильной консоли: x64 Native Tools Command Prompt for VS 20**!

6. Сборка тестового приложения

Исходники приложения можно скачать с репозитория или склонировать командой:

git clone https://github.com/devslm/kotlin-spring-boot-native-skeleton.git

Для чистоты эксперимента рекомендую удалить все файлы из каталога: /resources/META-INF/native-image, чтобы самостоятельно понаблюдать весь процесс сборки. Если что-то не получится, то можно использовать уже собранные мною файлы и проверить, что сборка проходит успешно.

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

6.1 MacOS

# Собираем приложение
gradle clean build

# Запускаем нативного агента
<path-to-graalvm-jdk-17>/java -Dspring.aot.enabled=true -agentlib:native-image-agent=config-merge-dir=./src/main/resources/META-INF/native-image -jar build/libs/kotlin-spring-boot-native-skeleton-1.0.0.jar

После запуска приложения стоит подождать некоторое время, чтобы все проинициализировалось и запустились различные скедулеры. Еще лучше если есть возможность повызывать endpoint’ы и пр.

Далее просто останавливаем приложение и увидим либо новые конфиг файлы в каталоге /resources/META-INF/native-image если это первый запуск, либо изменения в существующих.

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

gradle nativeCompile

После успешной сборки в каталоге: build/native/nativeCompile увидим бинарь приложения, который можем запустить из консоли.

Для оптимизации этой рутины я написал простой скрипт для сборки на Python в каталоге: ci/build.py. При его запуске он пройдется по всем этапам. С помощью параметра —aot-wait можно задать желаемое время ожидания в минутах работы приложения.

Только для его работы нужно в нем поменять путь до GraalVM Java в переменной GRAALM_HOME_PATH на свой путь.

Запуск скрипта из каталога приложения с временем работы приложения 1 минута в AOT режиме:

python3 ci/build.py --aot-wait 1

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

6.2 Windows

Необходимо создать каталог для сохранения зависимостей maven’a с максимально коротким путем. В моем случае это был: C:\m2.

Т.к. я обычно для сборки в Windows просто копирую каталог скомпиленного приложения с MacOS в котором уже был собран *.jar и собраны конфиги нативным агентом, то остается только выполнить команду компиляции:

gradle "-Dmaven.repo.local=C:\m2" --gradle-user-home=C:\m2 nativeCompile

Но если проект был склонирован непосредственно на Windows машину с репозитория, то необходимо выполнить все шаги как для MacOS, только в этот раз добавляем пути до нашего кастомного каталога .m2:

# Собираем приложение
gradle "-Dmaven.repo.local=C:\m2" --gradle-user-home=C:\m2 clean build

# Запускаем нативного агента
java "-Dspring.aot.enabled=true" -agentlib:native-image-agent=config-merge-dir=./src/main/resources/META-INF/native-image -jar build/libs/kotlin-spring-boot-native-skeleton-1.0.0.jar

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

gradle "-Dmaven.repo.local=C:\m2" --gradle-user-home=C:\m2 nativeCompile

После успешной сборки в каталоге: build/native/nativeCompile увидим бинарь приложения, который можем запустить просто двойным кликом.

7. Замеры времени старта, размера бинарей и потребления ресурсов

Картинка с сайта: habr.com

Картинка с сайта: habr.com

Как видно на скринах, нативное приложение стартует почти в 14 раз быстрее обычного *.jar. По мере обрастания функционалом время запуска будет расти у обычного приложения на секунды, а у нативного так и не будет больше 1 секунды!

Оперативки после старта нативное приложение занимает 100Mb, а обычное 350Mb (замеры только на момент старта).

Размер обычно *.jar файла получился 98.2Mb (учитываем что он пустой без логики) + размер архива обычной JDK 17 ~220Mb итого суммарный размер приложения ~320Mb.

Размер нативного приложения ~149Mb — и все. Причем этот стартовый размер будет всегда примерно одинаковым, т.к. нативное приложение не совсем нативный код, там содержится дополнительная среда чтобы все это работало (насколько помню Substrate VM). Но с ростом кодовой базы размер не будет уже сильно расти, размер моего приложения ~190Mb.

8. Послесловие

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

Изначально я разрабатывал его полностью на JavaFX и Spring Boot, но довольно быстро понял основные минусы — большой размер файла, долгий старт, большое потребление ресурсов и огромные затраты времени, чтобы поддержать приемлемый дизайн и UI для 2023-го года. Но именно долгий старт стал скорей всего решающим, т.к. его довольно часто может приходиться запускать. Защита от копирования и реверс инжиниринга так же была важна.

Далее мне пришла мысль нативно скомпилировать приложение, чтобы избавиться от основной проблемы долгого старта, к тому же я следил за проектом Spring Boot Native с первых дней его упоминания (я сразу увидел большие возможности). После попыток компиляции именно связки JavaFX + Spring Boot, у меня ничего так и не получилось. Скорей всего из-за того, что саму JavaFX нужно компилировать отдельно и есть специальный инструментарий.

И вот дальше мне пришла внезапно отличная идея — Electron + Backend на Kotlin и Spring Boot. Для web есть куча готовых красивых шаблонов, а backend станет простым REST сервисом и сам Electron соберет все это удобно в исполняемое приложение под каждую OS. Web часть написана на React.

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

Итоговый размер всего собранного приложения стал 212 Mb под MacOS (речь о финальном билде с Electron), а под Windows еще меньше. Стартует все приложение меньше секунды, почти не отличить от других нативных приложений.

Часто вижу мнения, что нативная компиляция чуть ли не революция в мире spring для контейнеризации, но после довольно большого опыта сборки — я, честно говоря, так особо не считаю. Да, это огромный шаг для Spring и Java/Kotlin за последние годы, открываются новые возможности о которых раньше только мечтали (создавали всякие костыли).
Но с другой стороны сборка очень трудо- и ресурсо- затратная, все это не так-то просто автоматизировать через CI и занимает очень много времени сборки, прям очень много. Как мне кажется, это просто решение в плане контейнеризации для каких-то специфических задач (каждый сам за себя).

Если к примеру, у вас 3-4 пода запускается в k8s, то смысла нет никакого, 15 минут компиляции не дадут большого буста относительно быстрого старта пода. Но, возможно, если у вас сотни или тысячи подов — то тут время сборки будет оправдано относительно времени старта всего кластера.

Спасибо за внимание!

Kotlin is a modern, statically typed programming language that runs on the Java Virtual Machine (JVM). Developed by JetBrains, Kotlin is designed to be more concise, safe, and interoperable with Java than its predecessor. As a general-purpose language, Kotlin is used for Android app development, backend development, and creating desktop applications. By installing Kotlin on your Windows machine, you can utilize its benefits, including improved code readability, reduced bugs, and seamless integration with Java libraries.

By learning Kotlin, Windows users can enhance their programming skills, creating more efficient and maintainable code. Kotlin’s concise syntax and null-safety features make it an attractive choice for developers looking to streamline their workflow. With Kotlin, you can develop a wide range of applications, from Android apps to enterprise software, all while enjoying the benefits of a modern, intuitive language.

In this guide, we’ll walk you through the simple process to install Kotlin Windows machine, so you can start exploring the world of Kotlin programming and take advantage of its many benefits.

Installing Kotlin on Windows

To install Kotlin on Windows, start by downloading the Kotlin compiler from its official GitHub page. GitHub is a popular platform for hosting open-source software projects, where you can access and download the latest stable versions.

Step 1: Download Kotlin from GitHub

Visit the official Kotlin GitHub Releases page to find the latest version of Kotlin. On the release page, scroll down to the “Assets” section, which lists files for different platforms and formats:

Картинка с сайта: ultahost.com

For most users, it’s recommended to download the Kotlin Compiler in .zip format (around 82 MB). This version supports essential tools for general Kotlin development on Windows. If you require Kotlin Native for specialized development, select the larger Kotlin Native Prebuilt (around 175 MB). Most Windows developers will find the Kotlin Compiler version sufficient.

In the “Assets” section, click the .zip file for the Kotlin Compiler to begin downloading. Once the download completes, you can proceed with the installation.

Once the .zip file download is complete, extract it to a folder in your desired location on your Windows system. This folder will contain the bin directory, which holds the Kotlin compiler executable files:

Картинка с сайта: ultahost.com

Step 3: Set the Binary Folder Path in Environment Variables

To make Kotlin accessible from any command prompt window, you need to add the path to the bin folder in your environment variables:

Open the Start Menu and search for Environment Variables. Select Edit the system environment variables to open the System Properties window:

Картинка с сайта: ultahost.com

Click New and add the path to the bin folder of your extracted Kotlin directory (for example, C:\path\to\kotlin\bin):

Картинка с сайта: ultahost.com

Click OK to save and close all windows.

This step allows you to use Kotlin commands directly from any command prompt window, making it easy to compile and run Kotlin programs.

Step 4: Verify the Kotlin Installation

To confirm that Kotlin is installed correctly and your system recognizes Kotlin commands you can open a terminal and type the following command:

Kotlinc -version

Картинка с сайта: ultahost.com

Features of Kotlin

Kotlin offers a range of powerful features that enhance productivity, code clarity, and ease of development. Below are some key features that make Kotlin a preferred language for many developers.

1. Concise Syntax

Kotlin’s syntax is designed to reduce boilerplate code. It allows developers to write clean, readable code with fewer lines, making the development process faster and reducing the chances of errors.

2. Null Safety

Null pointer exceptions are a common issue in many programming languages. Kotlin addresses this with built-in null safety, allowing developers to explicitly handle null values, which helps prevent crashes and improves the stability of applications.

3. Interoperability with Java

Kotlin is fully compatible with Java, meaning you can use existing Java libraries and frameworks within Kotlin projects. This feature makes it easy for Java developers to transition to Kotlin and integrate it into existing Java-based projects.

4. Extension Functions

Kotlin allows developers to add new functionalities to existing classes through extension functions without modifying the class itself. This feature enhances code flexibility and lets you keep your codebase modular and clean.

5. Coroutines for Asynchronous Programming

Kotlin’s support for coroutines simplifies asynchronous programming, making it easier to manage background tasks. This feature is especially useful in Android development, where handling complex tasks without blocking the main thread is essential for smooth performance.

6. Data Classes

Kotlin includes a specialized class type called “data classes” for handling data storage. These classes automatically generate essential functions like equals(), hashCode(), and toString(), reducing the need for boilerplate code and simplifying data management.

7. Strong Community and Tooling Support

Kotlin has excellent support from JetBrains and is backed by Google for Android development. It integrates smoothly with popular IDEs like IntelliJ IDEA and Android Studio, offering rich tooling support, such as code completion, debugging, and refactoring. To integrate Kotlin with IntelliJ IDEA first, you need to go through our guide on How to Install IntelliJ IDEA on Windows system.

8. Multi-platform Development

Kotlin’s multi-platform capabilities allow developers to write shared code for different platforms, including Android, iOS, and web applications. This feature makes it easier to build applications that run across multiple environments without duplicating code.

Conclusion

In this guide, we covered the comprehensive process of installing Kotlin on a Windows system, emphasizing the importance of downloading the Kotlin compiler from the official GitHub page. After downloading, we outlined the steps for extracting the files and setting the path to the bin directory in the environment variables. This configuration allows you to execute Kotlin commands directly from the Command Prompt. We also highlighted the necessity of having the Java Development Kit (JDK) installed, as Kotlin runs on the Java Virtual Machine (JVM), which is essential for executing Kotlin applications.

Once the installation is complete, verifying the setup involves checking the Kotlin version using the command line. The features of Kotlin, such as concise syntax, null safety, and full interoperability with Java, make it a powerful choice for developers. Additionally, Kotlin’s support for coroutines simplifies asynchronous programming, enhancing productivity. By following this installation process, you are now equipped to leverage Windows install Kotlin robust capabilities, enabling efficient development for Android and other platforms.

FAQ

Kotlin в IntelliJ IDEA

Писать программы на почти любом языке программирования можно в любом текстовом редакторе. Такие редакторы не следует путать с текстовыми приложениями, предназначенными для набора и оформления обычных текстов, которые читают люди. В то же время современные текстовые редакторы, предназначенные для набора исходного кода программ, поддерживают подсветку синтаксиса (выделяют слова разным цветом в зависимости от их значения), нередко выполняют автодополнение кода и автоматически делают отступы.

Однако подсветка синтаксиса не хранится в самом файле программы. В файле сохраняется только исходный код. Файл может быть открыт в любом другом текстовом редакторе, поддерживающем другой вариант подсветки или вообще ее не поддерживающий.

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

В случае Kotlin исходный код компилируется (в одном из вариантов) в байт-код Java. Такой код исполняется посредством виртуальной машины Java, следовательно, на компьютере также должна быть установлена JVM.

В настоящее время программисты реже озадачивают себя подбором наиболее подходящего редактора и установкой компиляторов. Чаще используют готовые среды разработки – приложения по принципу «все в одном». Здесь и редактор, и возможность запускать программу нажатием одной кнопки. За сценой среда сама компилирует и, в случае байт-кода вызывает JVM для его исполнения. Также такие IDE (integrated development environment – интегрированная среда разработки) содержат множество дополнительных инструментов, плагинов, возможность подключать различные библиотеки, расширяющие средства языка. Все, что необходимо для профессиональной разработки.

Самой адаптированной под Kotlin средой разработки является IntelliJ IDEA. Раньше в ней писались преимущественно программы на Java. Однако с появлением Kotlin данная среда стала поддерживать и его, так как разработчиками IntelliJ IDEA и языка Kotlin является одна и та же фирма – Jet Brains. Это не значит, что программировать на Котлин можно только в IntlliJ IDEA. Однако, особенно для начинающих, ее следует считать лучшим выбором, так как она помогает определять не только ошибки в коде, но также указывает на любые недочеты.

Фирма Jet Brains предоставляет среду в двух вариантах – Ultimate (максимальный) и Community (общественный). Второй является бесплатным. Его возможностей достаточно для большинства разработчиков. Скачать среду можно с сайта компании по адресу https://www.jetbrains.com/idea/

Если ни одни из предыдущих проектов не открыт, вы увидите окно «Welcome», в котором надо выбрать «Create New Project».

Далее в первом окне «New Project» в списке слева выбираем «Kotlin». Правее – способ сборки и исполнения – «JVM | IDEA».

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

После того как вы нажмете кнопку Finish, среда начнет генерировать систему каталогов и конфигурационные файлы проекта. Это может занять некоторое время. В конечном итоге слева на вкладке Project вы увидите дерево каталогов.

Среда сама добавит к файлу расширение «.kt», так как файл будет содержать код на Kotlin. Также файл откроется в рабочей области окна. Запишем в него небольшую программу на языке Kotlin.

Программа начинается с fun – это одно из ключевых слов языка Kotlin. Другими словами, является одной из команд. Команда fun означает, что будет определена функция. Подробно что такое функция, будет рассмотрено позже в данном курсе.

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

Далее идет открывающая фигурная скобка, которой соответствует закрывающая фигурная скобка в самом конце. Между фигурными скобками находится тело функции. Оно выполняется при вызове функции. Функция main() вызывается, когда программа запускается.

Обратите внимание на маленький зеленый треугольник, расположенный перед первой строчкой кода. Если у вас его нет, то закройте IntelliJ IDEA и откройте среду снова. Если кликнуть по треугольнику, появится меню, где надо выбрать первый вариант «Run …».

Строка «Process finished with exit code 0» говорит, что программа закончилась так как надо, а не аварийно или с ошибкой.

Снова обратим внимание на структуру каталогов проекта. В нем появится каталог «out», в котором находятся скомпилированные файлы проекта.

Мы можем посмотреть, что содержит StartKt.class, например, с помощью консольной утилиты cat.

Так выглядит байт-код Java нашей простейшей программы.

После первого запуска программы IntelliJ IDEA сама создаст конфигурацию запуска, после чего программу также можно запускать, нажимая треугольник на панели инструментов (Shift + F10).

IntelliJ IDEA – настраиваемая среда. Если вас не устраивают, например, размер шрифта и тема оформления, их можно поменять. Делается это в окне настроек (File → Settings).

Darcula – темная тема оформления.

Вопросы:

Каким цветом IntelliJ IDEA подчеркивает и выделяет ошибки в коде?

Что будет, если в конце выражения println(«…») поставить точку с запятой?

Возникнет ли ошибка, если перед println() убрать отступ? Зачем он нужен?

Источник

Урок 1. Разработка на Kotlin. Установка Android Studio

В первом уроке курса по разработке андроид-приложений на языке Kotlin мы установим необходимые средства для разработки приложений, такие как среда разработки Android Studio.

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

Установка Android Studio на компьютер

В этом курсе мы создадим приложение Android на языке Kotlin, используя официальную среду разработки Android Studio. Android Studio — это IDE, созданная на базе программного обеспечения IntelliJ IDEA от JetBrains специально для разработки Android-приложений. Для создания приложений в Kotlin необходимо установить Android Studio 3.0 или более поздней версии.

Среда Android Studio доступна для компьютеров под управлением Windows, Mac и Linux. Установка практически аналогична для всех платформ. Некоторые различия описаны в подробной инструкции по установке на нашем сайте fandroid.info.

Примечание: Последние сведения о системных требованиях и инструкциях по установке содержатся в официальной документации на сайте developer.android.com/studio.

Если вы используете компьютер, на котором уже установлена ​​Android Studio версии 3.0 и выше, переходите к следующему уроку, в котором мы создадим первый проект.

Android Studio использует инструменты Java Develipment Kit в работе. До недавнего времени перед установкой Android Studio нужно было скачать и установить JDK версии 7 или 8 с официального сайта Oracle. Сейчас такой необходимости нет, поскольку Android Studio уже содержит встроенный пакет инструментов JDK.

Если вам необходимо установить официальный JDK, следуйте инструкции Установка JDK (Java Development Kit) на нашем сайте fandroid.info, ссылка под видео.

Установка Android Studio

На данный момент доступна для загрузки версия Android Studio 3.0.

Скачайте дистрибутив для вашей операционной системы

В процессе скачивания можно ознакомится с видео инструкциями по установке Android Studio для вашей операционной системы.

К созданию проекта мы перейдем в следующем уроке, а пока на стартовом экране откройте в меню Configure> SDK Manager, который управляет всеми установленными компонентами среды разработки.

Картинка с сайта: hand.post-ap.ru

На вкладке SDK Platforms можно увидеть, что загружена только последняя версия Android. Нужно пометить для загрузки несколько последних версий, самых популярных на текущий момент, и скачать их. Процесс загрузки и распаковки происходит автоматически, вам следует только набраться терпения и дождаться его окончания. После окончания установки вы увидите в окне SDK Manager, что выбранные компоненты помечены как загруженные.

Самые популярные версии Android на текущий момент можно посмотреть в статистике на официальном сайте https://developer.android.com/about/dashboards/index.html

Возможные проблемы: Если имя пользователя ПК в Windows написано кириллицей, то Android Studio не будет правильно работать, поскольку среда разработки не читает кириллицу в пути к файлам. Переименуйте пользователя английскими буквами.

При возникновении проблем с установкой вы можете задать вопросы в комментариях под видео на канале Start Android и в комментариях ниже. Кроме того, вы можете воспользоваться различными форумами по программированию, такими как StackOverFlow. Обычно бывает достаточно ввести часть текста ошибки в поиске на StackOverFlow, чтобы найти подсказку к решению проблемы.

На этом наш урок подошел к завершению. А на следующем уроке мы создадим проект в среде разработки Android Studio и запустим первое приложение на андроид-устройстве.

Источник

Введение в язык Kotlin

Что такое Kotlin. Первая программа

Kotlin представляет статически типизированный язык программирования от компании JetBrains. Kotlin можно использовать для создания мобильных и веб-приложений.

Первая версия языка вышла 15 февраля 2016 года. Хотя сама разработка языка велась с 2010 года. Текущей версией языка на данный момент является версия 1.2, которая вышла 28 ноября 2017 года.

Также стоит отметить, что Kotin развивается как opensource, исходный код проекта можно посмотреть в репозитории на github по адресу https://github.com/JetBrains/kotlin/.

Kotlin испытал влияние многих языков: Java, Scala, Groovy, C#, JavaScript, Swift и позволяет писать программы как в объектно-ориентированном, так и в функциональном стиле. Он имеет ясный и понятный синтаксис и довольно легок для обучения.

Самым популярным направлением, где применяется Kotlin, является прежде всего разработка под ОС Android. Причем настолько популярным, что компания Google на конференции Google I/O 2017 провозгласила Kotlin одним из официальных языков для разработки под Android (наряду с Java и C++), а инструменты по работе с данным языком были по умолчанию включены в функционал среды разработки Android Strudio начиная с версии 3.0.

Первая программа на Kotlin

Создадим первую программу на языке Kotlin. Что для этого необходимо? Для набора кода программы понадобится текстовый редактор. Это может быть любой тестовый редактор, например, встроенный блокнот или Notepad++. И для компиляции программы необходим компилятор.

Загрузить компилятор непосредственно для самого языка Kotlin можно по адресу https://github.com/JetBrains/kotlin/releases/tag/v1.2.0.

Картинка с сайта: hand.post-ap.ru

Картинка с сайта: hand.post-ap.ru

Далее определим в этом файле код, который будет выводить некоторое сообщение на консоль:

Эта функция принимает параметр args, который представляет массив строк.

Картинка с сайта: hand.post-ap.ru

Откроем командную строку. Вначале с помощью команды cd перейдем к папке, где находится файл app.kt. Затем для компиляции программы введем следующую команду:

После выполнения этой команды будет создан файл app.jar. Теперь запустим его на выполнение. Для этого введем команду

В данном случае считается, что путь к JDK, установленном на компьютере, прописан в переменной PATH в переменных среды. Иначе вместо «java» придется писать полный путь к утилите java.

В итоге при запуске файла мы увидим на консоли строку «Hello Kotlin».

Источник

Интернационализация и локализация приложения на Kotlin/Native

こんにちは, или добрый день по-японски.

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

Поэтому далее мы пошагово рассмотрим процесс адаптации консольного приложения для Linux на Kotlin/Native к русской и английской локали.

Поможет нам в этом старый-добрый GNU gettext.

В итоге убедимся, что это совсем не страшно.

Заодно посмотрим интеграцию с библиотеками на C, которая значительно расширяет возможности Kotlin/Native.

Что напишем: переводчик количественных числительных на японский язык.

Что ожидается от читателя: знание языков программирования Kotlin, C, базовый уровень знакомства с ОС Linux (в частности Bash).

Что понадобится в процессе: любой дистрибутив Linux, любая версия IntelliJ IDEA, установленный пакет gettext-devel или аналогичный.

Картинка с сайта: hand.post-ap.ru

Мотивация

Где-то полгода медленно и печально изучаю японский язык по учебнику “Minna no Nihongo”: частью ради перевода текста песен, частью просто из интереса к культуре.

Позже решил перейти с системной разработки на прикладную, с десктопа на мобильные платформы, соответственно с C++/Qt/STL на Kotlin/JVM/Android SDK.

Теперь хочу два этих занятия совместить, написав для себя программы для помощи в изучении японского. Конечно, уже много готовых, но NIH-синдром ведь не что-то плохое, правда?

Раньше я не задумываюсь использовал бы связку Qt/QML/C++: она позволяет быстро и эффективно решать в общем-то любые задачи и на любой платформе.

Однако Qt всё больше поворачивается спиной к Open Source, вот и решил пора валить попробовать что-то другое.

И тут в процессе изучения Kotlin узнал про Kotlin/Native.

Соответственно, первая программа-помощник будет именно на нём.

Что такое Kotlin/Native

Изначально Kotlin выступал в качестве «более лучшей» (С) Java, и целиком опирался на платформу JVM.

Однако затем компания JetBrains, разработчик Kotlin, решила адаптировать набирающий популярность язык и под другие платформы.

В частности, под веб (Kotlin/JS) и под «натив» (Kotlin/Native).

Kotlin/Native появился в марте 2017 года, кстати ровно четыре года назад.

Он позволяет компилировать код на Kotlin в нативный код с помощью LLVM, без зависимости от виртуальной машины JVM и других библиотек.

Далее мои субъективные впечатления по опыту разработки демонстрационного приложения, так что буду рад исправлениям и дополнениям.

исходный код под пермиссивной открытой лицензией (Apache-2.0 license)

работа на всех поддерживаемых LLVM платформах, в частности iOS и десктопы

генерирует единственный исполняемый файл без сторонних зависимостей

низкое потребление системных ресурсов

доступны все базовые «вкусности» Kotlin вроде коллекций и функционального программирования

есть прозрачный interop с языком C

как следствие: доступны low-level функции платформы, в частности POSIX

стандартная библиотека весьма бедная по сравнению с огромной JVM, многое придётся писать с нуля (пример: оставьте только пункт Native тут)

нет стабильной библиотеки для GUI, хотя есть некоторые привязки через C interop (GTK, libui)

слабый инструментарий по сравнению с той же Android Studio, например нет той же локализации

относительно долгое время сборки

Больше о Kotlin/Native можно почитать тут, а примеры доступны на Github.

Терминология

Интернационализация (i18n): подготовка приложения к локализации, обычно выполняется разработчиками.

Локализация (l18n): Процесс перевода и адаптации контента приложения для конкретных языков, обычно выполняется переводчиками.

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

Что такое GNU gettext

Этот пакет из нескольких утилит, библиотек и регламентов.

правила оформления исходного кода для последующей интернационализации

утилиты для генерации текстовых файлов с локализуемыми строками

кроссплатформенная нативная библиотека для извлечения переводов в runtime

правила дистрибуции бинарных файлов с переводами

Почему GNU gettext

Интернационализация в Kotlin/JVM для Android использует средства Android SDK, в частности строковые ресурсы, и завязана на JVM.

Поэтому для Kotlin/Native эти средства недоступны.

В Qt есть собственный инструментарий, но его не получится использовать вне Qt, тем более с отличным от C++ языком.

Поэтому остаётся GNU gettext:

универсальный (поддерживается множество языков программирования)

кроссплатформенный (Win/Mac/Linux, есть Android/iOS версия)

стабильный в силу почтенного возраста

Демонстрационный проект

Суть: консольная программа пока только под Linux, чтобы не переусложнять код.

Функционал: читает натуральное число из аргумента командной строки или stdin, и переводит его в количественное числительное на японском.

Число может содержать специфичные для локали разделители тысяч, которая программа выводит при запуске.

Скачать проект можно на Github и затем открыть в IntelliJ IDEA.

Характеристики исполняемых файлов

Для начала время полной сборки:

18 сек на конфигурации Ryzen 3900X + 32GB DDR4-3600 + NVM-E SSD. На мой взгляд многовато для такого маленького проекта и такой конфигурации.

Тут можно вспомнить о преимуществах скриптовых языков, которые компилировать не надо.

Теперь посмотрим свойства исполняемого файла для отладочной и релизной конфигураций:

Размеры скомпилированных исполняемых файлов

Тут всё в порядке, бинарники скромные по размеру и без каких-либо сторонних зависимостей.

Отладка проекта

Она не работает, по крайней мере в Community Edition.

Просто игнорируются точки останова, хотя судя по выводу команды file отладочные символы в исполняемом файле есть.

Насколько я понял, соответствующий плагин доступен только в платной редакции IDE, которая пока для меня избыточна.

Прошу поправить, если ошибаюсь.

Так что для написания демо пришлось обходиться printf-driven отладкой, ну мне не привыкать после Android AOSP.

Интернационализация

В случае нашего проекта нужно лишь все локализуемые строки «обернуть» в вызов функции gettext().

Для краткости можно сделать синоним этой функции, например tr(), это общепринятая практика.

Понадобится ещё служебный код для работы с POSIX-локалями, он находится в файле Locale.kt.

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

Перевод локализуемых строк

Я написал Bash-скрипты для генерации с нуля и обновления файлов gettext:

Далее вкратце опишу основные шаги, которые они выполняют.

Генерируем pot-файл («шаблон»), который содержит базовую информацию о программе и собственно строки нуждающиеся в переводе.

Генерируем po-файл (текстовый перевод):

Генерируем mo-файл (бинарный перевод):

Развертывание бинарных файлов с переводами

К сожалению, Kotlin/Native не поддерживает ресурсы, так что «упаковать» mo-файлы в исполняемый файл пока не выйдет.

На это есть соответствующий баг.

Думаю, функционал ресурсов можно реализовать и вручную дополнительной задачей в Gradle, это пожалуй тема для отдельной статьи.

Для тестового проекта положим mo-файлы рядом с приложением, где не нужны права суперпользователя и где gettext сможет их найти.

Как видите, процесс несложен, по крайней мере при наличии готового кода и скриптов.

Источник

Kotlin 1.3 с поддержкой корутин, бета-версией Kotlin/Native и не только

На днях вышел Kotlin 1.3 с комплектом сопутствующих библиотек, инструментов сборки и учебных материалов.

Мы делаем Kotlin как инструмент для разработки приложений любого масштаба на любых платформах. В Kotlin 1.3, благодаря корутинам, читать и писать неблокирующий асинхронный код стало легко и удобно. Масштабируемость стала гораздо доступнее. В новом релизе мы также выпустили бета-версию Kotlin/Native, позволяющую компилировать код Kotlin непосредственно в машинный код. Мультиплатформенные возможности Kotlin теперь работают на всех поддерживаемых платформах, что позволяет, например, использовать одну и ту же бизнес-логику в приложениях для Android и iOS. Общую логику можно также использовать для серверов и мобильных и веб-клиентов. Кроме того, появилась возможность писать легко переносимые мультиплатформенные библиотеки, которые возьмут на себя большинство повседневных задач.

Картинка с сайта: hand.post-ap.ru

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

Сообщество и экосистема

В этом году экосистема Kotlin росла беспрецедентными темпами. С января 2018 года код на Kotlin редактировали приблизительно 1,5 миллиона пользователей — по сравнению с прошлым годом их число более чем удвоилось. База знаний на StackOverflow и в нашем публичном Slack тоже растет впечатляющими темпами. И мы очень рады, что сообщество Kotlin такое отзывчивое и доброжелательное.

Нам нравится, как растет и развивается экосистема, сложившаяся вокруг Kotlin. Kotlin дружит с Google Cloud Platform, Spring Framework и Gradle, не говоря уже об официальной поддержке на платформе Android. Сообщество open source создает превосходные библиотеки, такие как RxKotlin, mockito-kotlin, TornadoFX, Kodein и ΛRROW. Уже переходят на Kotlin или планируют миграцию такие проекты, как Square’s Okio и LibreOffice. Приглашаем всех присоединяться к экосистеме Kotlin со своими идеями и проектами.

В Kotlin 1.3 внесли свой вклад не только сотрудники JetBrains, но и многие другие люди, которые создавали пулл-реквесты, баг-репорты и поддерживали с нами всяческую обратную связь. Мы очень ценим вашу помощь в развитии Kotlin!

Корутины официально стабильны

Корутины — это современный способ написания неблокирующего асинхронного кода, который легко понимать и удобно дорабатывать. Этот мощный инструмент можно использовать в самых разных целях — от перекладывания вычислительной нагрузки на фоновые исполнители (worker) до реализации сложных сетевых протоколов. Библиотека kotlinx.coroutines, версия 1.0 которой вошла в этот релиз, представляет собой прочный фундамент для управления асинхронными задачами в любом масштабе, включая их составление, отмену, обработку исключений и случаи, связанные с пользовательским интерфейсом.

Kotlin/Native Beta

Kotlin/Native использует LLVM для компиляции исходных кодов на Kotlin в самостоятельные двоичные файлы (виртуальная машина не нужна) для разнообразных операционных платформ и процессорных архитектур, включая iOS, Linux, Windows, Mac и даже WebAssembly и встраиваемые системы, такие как STM32. Kotlin/Native поддерживает полностью автоматическое управление памятью, обеспечивает взаимодействие с C и Objective-C (и Swift) и позволяет работать с API платформ, такими как Core Foundation или POSIX, и любыми нативными библиотеками, которые могут понадобиться разработчику.

Среда выполнения Kotlin/Native поощряет использование неизменяемых данных и запрещает любые попытки передачи незащищенного изменяемого состояния между потоками. На самом деле с точки зрения Kotlin/Native потоков не существует, они абстрагированы в качестве низкоуровневого аспекта реализации и заменены исполнителями (worker) — это безопасный и удобный способ реализации параллелизма.

Познакомиться с Kotlin/Native можно по адресу kotl.in/native.

Мультиплатформенные проекты и инструменты

Перед Kotlin в явном виде поставлена задача работать на всех платформах, однако мы рассматриваем ее как предпосылку к более важной цели — использованию одного и того же кода на разных платформах. Поддержка JVM, Android, JavaScript и Native позволяет Kotlin работать с любыми компонентами современных приложений. А это дает бесценную возможность переиспользования кода и имеющихся наработок — ведь куда лучше сосредоточиться на решении действительно сложных задач, а не на реализации того же самого кода по два раза и больше. Хотя мультиплатформенные возможности в Kotlin остаются экспериментальными, версия 1.3 — это большой шаг вперед.

Вместе с Kotlin 1.3 поставляется комплект мультиплатформенных библиотек для всех повседневных задач, например: HTTP, сериализация и управление корутинами. Использование подобных библиотек — самый простой способ писать мультиплатформенный код. Кроме того, вы можете создавать и собственные мультиплатформенные библиотеки, абстрагирующие особенности определенных платформ в едином API.

Начните переиспользовать код на разных платформах уже сегодня: kotl.in/multiplatform.

Инструменты для Kotlin/Native и Multiplatform

В Kotlin 1.3 доступны инструменты разработки Kotlin/Native и мультиплатформенных проектов в средах разработки IntelliJ IDEA Community Edition, IntelliJ IDEA Ultimate и Android Studio. Во всех трех IDE можно использовать всю функциональность редактирования кода — подсветку ошибок, комплишен, навигацию и рефакторинг. В будущем мы займемся реализацией более сложных возможностей и интеграцией с коммерческими инструментами.

Ktor 1.0 Beta

Ktor — наш фреймворк для взаимосвязанных приложений, реализующий весь стек HTTP с полной асинхронностью на основе корутин, — уже в бета-версии и доступен по адресу ktor.io.

Другие улучшения

Кроме всего вышеупомянутого в этом релизе появился целый ряд других возможностей и улучшений:

KotlinConf

Мы опубликовали все видео с конференции KotlinConf 2018, на которой обсуждались главные темы Kotlin 1.3. Посмотрите вступительный кейноут, чтобы подробнее разобраться во всем самом новом и важном:

Записи всех семинаров с KotlinConf 2018 доступны на JetBrains TV.

Изучение Kotlin

Мы очень стараемся сделать изучение Kotlin легким и приятным. Для этого существует много ресурсов, среди которых мы хотели бы выделить следующие:

Как обновиться

Как и всегда, вы можете попробовать Kotlin онлайн по адресу play.kotl.in.

Ваша команда JetBrains
The Drive to Develop

Источник