Auto Added by WPeMatico

kotlinx.serialization 1.2 のリリース: JSON 高速処理、値クラスのサポート、ドキュメントの見直しなど

先日、

kotlinx.serialization

1.2 がリリースされました! 当社のマルチプラットフォーム向けシリアル化ライブラリの最新バージョンにはいくつかの改善点が盛り込まれています。以下、その概要を紹介します。

バージョン 1.2 には、JSON フィールドの代替名に対するサポートが新しく盛り込まれているほか、それにより、Kotlin クラスから自動的に Protobuf スキーマを生成する新しい実験的なアプローチも提供されています。この機能については、ぜひご意見をお聞かせください!

それでは、今回の新バージョンに関する変更点や追加機能を一緒に見ていきましょう! 既に十分理解されているという方は、下のアップグレード手順にジャンプしていただいて構いません!

kotlinx.serialization 1.2 を始める!

Kotlin YouTube チャンネルに登録!!

これまでで最速となる JSON のエンコード・デコード

Kotlin クラスを JSON の文字列にエンコードする機能と JSON の文字列を Kotlin クラスに変換する機能は、

kotlinx.serialization

の機能の中で最も一般的に使用されるものであるため、当社は常にパフォーマンスの改善に取り組んでいます。

kotlinx.serialization を使った JSON の解析: 最高で 55% もスピードアップ

バージョン 1.2 では、

kotlinx.serialization

の内部構造が全面的に見直され、このコア機能のパフォーマンスが大幅に改善されています。 JSON デコーダー (テキストを Kotlin オブジェクトに変換) を書き直し、JSON エンコーダー (Kotlin オブジェクトをテキストに変換) に対する大幅な最適化も実施しました。

kotlinx.serialization を使った JSON のエンコード: 最高で 339% もスピードアップ

最新のライブラリにアップグレードするだけで、典型的なエンコードとデコードの処理速度が最高で 2 倍もアップすることが期待できます。 (見てお分かりの通り、内部ベンチマークの中には、こうした新しい最適化が大きなメリットとなり、この数字を超えるものもあります!)

こうした変更が加えられたことで、

kotlinx.serialization

は、そのままの状態で JSON の他のライブラリと同等のパフォーマンスを実現し、いくつかの点ではより高いレベルに達しています。 今回の見直しでは、とてもシンプルなスニペットにまでメリットがあります。

@Serializable
data class User(val name: String, val yearOfBirth: Int)

fun main() {
// Faster encoding...
val data = User("Louis", 1901)
val string = Json.encodeToString(data)
println(string) // {"name":"Louis","yearOfBirth":1901}

// ...and faster decoding!
val obj = Json.decodeFromString(string)
println(obj) // User(name=Louis, yearOfBirth=1901)
}

当社のライブラリの最新バージョンを基準にご自分のアプリケーションを評価すれば、こうした改善内容の効果を最も強く実感していただけると思います。 パフォーマンス数値の大まかな傾向は、エンコードデコードに関する当社の内部ベンチマークをご覧ください。

kotlinx.serialization

の最新バージョンと前のリリースを比較した内容となっています。

値クラスと符号なしの数値型に対する JSON シリアル化 (逆シリアル化) が stable に

Kotlin 1.5.0 では、値クラス符号なし整数型 という 2 つの便利な機能が追加されています。これらに対し、

kotlinx.serialization

1.2 では、JSON のエンコードおよびデコードに対するファーストクラスのサポートが導入されました。 では、詳しく見てみましょう。

値クラスのサポート

値クラス (旧名 inline クラス) は、Kotlin の別の型 (number など) を実行時のオーバーヘッドを増やさずに型安全な手段を使ってラップするための方法です。 これにより、プログラムをより詳細に表現できるほか、安全性を高めることもできるため、パフォーマンスが低下することもありません。

kotlinx.serialization

に備えられている JSON のシリアル化機能は値クラスに対しても使えるようになりました。 Kotlin の他のクラスと同様に、

value class

@Serializable

のアノテーションを付けるだけで OK です。

@Serializable
value class Color(val rgb: Int)

値クラスは、その基底型として直接保存 (およびシリアル化) されます。 これは、

value class

型のフィールドをシリアル化可能な

データクラス

に追加し、その出力を検査すれば確認できます。


@Serializable
data class NamedColor(val color: Color, val name: String)
fun main() {
println(Json.encodeToString(NamedColor(Color(0), "black")))
}

// {"color": 0, "name": "black"}

上の例の

NamedColor

では、

値クラス
Color

基底のプリミティブ型 (

Int

) として扱われています。 つまり、こうした型を正確にシリアル化した表現のメリットを得ながら、Kotlin コード内で最大の型安全を活用でき、不要なボックス化やネストは行う必要がありません。

値クラス用のカスタムシリアライザのデザインは、現在も改良中ですので、現時点でも実験的な使用となってます。 このトピックに関する詳細は、GitHub に記載のこちらの docs をご覧ください。

符号なし整数のサポート

符号なし整数は、Kotlin の標準ライブラリに新たに加わった種類の整数で、負以外の数値の型を使用したり、演算を行ったりすることができます。 Kotlin 1.5.0 のリリースにより、以下の符号なし数値型を使用できるようになりました。

  • UByte

    、0~255 の値

  • UShort

    、0~65535 の値

  • UInt

    、0~2^32 – 1 の値

  • ULong

    、0~2^64 – 1 の値

kotlinx.serialization

の JSON エンコーダーとデコーダーは、初期設定の状態でこれらの型をサポートしています。 他の数値型と同様に、符号なし整数型も切り捨てやラッピング、符号付きの型への変換などはされずに、通常の数値表現 (

.toString

を呼び出したときと同じ表現) でシリアル化されます。

@Serializable
class Counter(val counted: UByte, val description: String)

@Serializable
class BigCounter(val counted: ULong)

val counted = 239.toUByte()
println(Json.encodeToString(Counter(counted, "tries")))
// {"counted":239,"description":"tries"}

println(Json.encodeToString(BigCounter(ULong.MAX_VALUE)))
// {"counted":18446744073709551615}

値クラスと符号なし整数の使用は、現在 JSON でサポートされています。 今後のリリースでは、CBOR と Protobuf の直接的な統合も提供しますので、ご期待ください!

kotlinx.serialization

やプログラミング言語 Kotlin の今後のリリースに関する最新情報を把握しておきたい方は、本ブログ記事の横にあるフォームより Kotlin 製品の最新情報に関するニュースレターに登録してください。

kotlinx.serialization

における値クラスと符号なし型の使用に関する詳細は、documentation on GitHub をご覧ください。

JSON フィールドに使う代替名のサポート

後方互換性を維持するためなどの理由から、意味は同じでも、名前が異なる JSON フィールドをパースしないといけない場合があります。 新しい

@JsonNames

アノテーションを使えば、JSON フィールドに代替名を付けられるようになりました。この代替名はデコーディングのプロセスを通して使用されます。

これを説明するために、例を 1 つ見てみましょう。 バージョンにより、サーバーは以下の 2 つのレスポンスのどちらかを返すと仮定しましょう。

{"name":"kotlinx.serialization"}
/* ...or: */
{"title":"kotlinx.serialization"}

name

title

は、ともに同じ意味を持っているため、これらを私たちの Kotlin クラス内にある同じフィールドにマッピングしたいとします。 新しい

@JsonNames

アノテーションを使用すれば、

title

name

キーの代替キーとして指定することができます。

@Serializable
data class Project(@JsonNames("title") val name: String)

これは、エンコーディングとデコーディングの両方でフィールドの名前変更を許可する一方で、代替の指定は許可しないという

@SerialName

アノテーションとは異なることに注意してください。

この機能により、同じ値を意味するが違う名前を持つフィールドを返すサービスの操作やスキーマの移行、アプリケーションのスムーズなアップグレードが簡単に行えるようになることを期待しています!

新しくなった API ドキュメント

kotlinx.serialization

をできるだけ安心して、楽しく学んでいただけるよう、当社は数多くの参照資料を提供することに努めています。 その 1 つが Kotlin Serialization Guide on GitHub です。ライブラリが提供する機能の手引きとなっており、大切なポイントをすべて盛り込んだ例がいくつも含まれているため、各機能を直感的に理解できるなっています。

他にも、全面的に改訂した kotlinx.serialization API documentation があります。 Kotlin のドキュメンテーションエンジン Dokka の最新バージョンに基づき、新しい API ドキュメントには、新しいレスポンシブかつモダンなデザインや理解しやすいシンボルが採用されています。

新しい API ドキュメントの例、表示されているのは JsonElement ドキュメント

kotlinx.serialization の新しくなった API ドキュメントを詳しくご覧ください!

Protobuf: Kotlin クラスからのスキーマ生成の実験的サポート

Protocol Buffers (Protobuf) は、Google が開発したバイナリシリアル化の形式であり、構造化されたデータに使用されます。 バイナリ形式であるため、JSON や XML よりも空間効率が優れていると同時に、アプリケーション間でのコミュニケーションに使用できる言語に依存しない構造を提供します。

kotlinx.serialization

では、実験的安定性(experimental)としてマルチプラットフォーム対応の Protobuf を使ったシリアル化 (proto2 セマンティクスを使用) を行えます。 他の形式と同様に、クラスは

@Serializable

として注釈し、ビルトインメソッド

encode

/

decode

を使用します。

@Serializable
data class Project(val name: String, val language: String)

fun main() {
val data = Project("kotlinx.serialization", "Kotlin")
val bytes = ProtoBuf.encodeToByteArray(data)
println(bytes.toAsciiHexString())
val obj = ProtoBuf.decodeFromByteArray(bytes)
println(obj)
}

Kotlin クラスをいわゆる信頼できる情報源(source of truth)とし、また便利なカスタマイゼーションも使用することにより、

kotlinx.serialization

は、データのバイナリスキーマを推論することが可能です。これによりProtobuf コミュニケーションを複数の Kotlin アプリケーション間で簡潔で便利に行うことができるようになります。

kotlinx.serialization

1.2 には、Protocol Buffers の実験的なスキーマジェネレーターも搭載されました。 Kotlin のデータクラスから

.proto

ファイルを生成することができます。また、それを使って Python や C++, TypeScript など、他の言語でコミュニケーションスキーマを表現することができます。

新しいスキーマジェネレーターの使用を開始する手順については、ドキュメントの該当する手順をご覧ください。

.proto

ファイルが生成されたら、リポジトリに保管し、他の言語で表現された Kotlin クラスを生成することに使用できます。 これにより、Kotlin のソースコード内で直接スキーマを管理できるという利便性を維持しながら、複数言語のアプリケーションでも

kotlinx.serialization

が提供する Protobuf との統合を簡単に活用できるようになることを期待しています。

これは Protobuf スキーマジェネレーターの最初のイテレーションということもあり、皆さまからのフィードバックを特に重要視しています。 是非ともお試しください。皆さまのユースケース、モデルや

.proto

ファイルの管理方法、直面した問題、あればいいなと思われる機能などを GitHub の課題トラッカーより知らせください。

スキーマジェネレーターを使用する際は、いくつか制限がありますので覚えておきましょう。 大まかな原則としては、

kotlinx.serialization

に搭載されている protobuf の実装を使って Kotlin クラスをシリアル化できる場合は、スキーマジェネレーターがそれをサポートするようになっています。 これは、同じ制限が適用されるということでもあります。 以下、注意点をいくつか紹介します。

  • Kotlin のクラス名とプロパティ名は、protobuf の仕様に準拠する必要があり、不正な文字を含まない。
  • Kotlin の null 許容性はスキーマに反映されない (proto2 はそれ専用のセマンティクスを持たないため)。 Protocol Buffer が提供するオプションのフィールドは、Kotlin のプロパティがデフォルト値を定義するかどうかに基づいて使用される。
  • Kotlin のデフォルト値はスキーマに含まれない。 (つまり、別の言語での実装においてもデフォルト値の一貫性を自ら保証する必要があります。)

kotlinx.serialization 1.2 をご使用ください!

本リリースの概要は以上です! JSON の高速化されたエンコーディング・デコーディング機能 や Kotlin 1.5 で新たに追加された型システムのサポート、Protobuf のスキーマ生成などをさっそく活用したいという方は、今すぐアップグレードしてください!

kotlinx.serialization

を既に使用されている方は、バージョン 1.2 にすばやくアップグレードしていただけます (

kotlinx.serialization

をまだお試しでない方は、是非このタイミングで始めてください!) まずは、

build.gradle.kts

ファイルの

plugins

ブロックを更新します。

plugins {
kotlin("jvm") version "1.5.0" // or kotlin("multiplatform") or any other kotlin plugin
kotlin("plugin.serialization") version "1.5.0"
}

そして、ランタイムライブラリで 

dependencies

ブロックを更新し、アプリケーションで使用する形式なども一緒に更新します。

dependencies {
implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.2.1")
implementation("org.jetbrains.kotlinx:kotlinx-serialization-protobuf:1.2.1")
// . . .
}

動画とその他の情報

問題に直面した場合

Kotlin YouTube チャンネルにご登録ください! 楽しく (デ) シリアル化しましょう!

Continue Readingkotlinx.serialization 1.2 のリリース: JSON 高速処理、値クラスのサポート、ドキュメントの見直しなど

The Kotlin YouTube Channel

The Kotlin community has always been the greatest source of inspiration for our team. We aspire to make the life of every Kotlin developer better, and we do our best to listen to all your feedback. With the increasing demand for more Kotlin-related video content, we would like to draw your attention to the Kotlin YouTube channel. It will help you connect with other Kotlin enthusiasts, stay up to date with what we are doing in the Kotlin team, and learn new skills from the comfort of your couch.

The Kotlin YouTube channel was launched on January 18, 2021, and has since grown to have more than 9 thousand subscribers, who can expect a new video every week. Over these 2 and a half months, we have introduced a multitude of formats, including pre-recorded videos, live webinars, and a bi-weeikly video podcast.

Subscribe to the Kotlin YouTube channel!

Here is a short summary of all of the series and formats that are currently available:

Spring Time in Kotlin

In this series you will learn how Kotlin and Spring work hand-in-hand to make you more productive while building server-side applications. Together with Anton Arhipov you will build a simple service with a database and extend it to try different Spring APIs. All the episodes are accompanied by code samples, so it will be easy for you to follow along and start using Kotlin to build Spring applications.

Webinars with experts

During our webinars, experts from different companies explain how to use Kotlin for a variety of purposes and answer questions during Q&A sessions. Speakers from JetBrains, VMware, Confluent, and Oracle have covered reactive programming, asynchronous applications with the Ktor framework, building microservices with Helidon, and other aspects of using Kotlin for server-side development. There are also special tracks on competitive programming and Kotlin for education, and more webinars are still to come! Subscribe to take part in the webinars and ask your questions during the live Q&A sessions! Recordings of these events will be also available after on the channel.

Kotlin Standard Library Safari

Learn about the features you get out of the box with Kotlin! If you know how to wield it, the Kotlin standard library is a powerful tool that can help you solve problems more effectively and be more expressive in your code. Together with Sebastian Aigner, we go through the useful functionality the standard library in Kotlin has to offer. In the process, we together unearth some hidden gems that could come in handy the next time you write Kotlin code.

Talking Kotlin

Since 2017, the Talking Kotlin Podcast has been the place to hear from people of different backgrounds and specializations about how they use Kotlin. Following its move to YouTube, Sebastian Aigner has joined Hadi Hariri as a co-host and we have already had conversations about the present and the future of Kotlin with its new project lead, Roman Elizarov, and about Kotlin Multiplatform with John O’Reilly. In each episode we are joined by interesting guests who offer insights into their experiences of using Kotlin in a variety of exciting fields.

Kotlin Multiplatform Multiverse

In this series of videos, Kate Petrova will show you how to use Kotlin Multiplatform Mobile for developing apps for iOS and Android from a single codebase. You will start by creating a simple application and proceed to look at a typical KMM-project structure. After learning the basics of KMM, you will see how to use it in real projects and understand how to make the process of developing cross-platform mobile apps with Kotlin Multiplatform efficient and enjoyable.

Plans for the future

We’re not stopping there. We’re exploring additional formats that will allow us to provide even more Kotlin content for you to enjoy. We have plans to bring more people from the team to the channel and organize special video events dedicated to certain milestones in the language. For example, we plan to do something special for the upcoming Kotlin 1.5 release.

Subscribe to our YouTube channel to never miss a thing!

As we continue to develop the official YouTube channel for Kotlin, we would like to pause for a moment to say thank you to everyone who inspired us to make all of this happen. We love reading your comments under the videos, and we continuously strive to make the channel better and provide content that you, our community, will find helpful. Please leave your ideas for a new series here, or under any of our videos, and we’ll do our best to bring them to the channel.

Continue ReadingThe Kotlin YouTube Channel

New Release Cadence for Kotlin and the IntelliJ Kotlin Plugin

TL;DR

  1. From now on, we will release Kotlin 1.X every six months. These releases will be date-driven, not feature-driven.
  2. The Kotlin IDE plugin will be released simultaneously with Kotlin, and on top of that — every time IntelliJ IDEA is released. Major IDE features will arrive in releases synchronized with IntelliJ IDEA.

Why the new cadence?

Since Kotlin 1.0 came out in 2016, we’ve built our release schedule around new key features in the language. This meant that until big language features were ready we would not release anything at all. As a consequence, we delivered changes and improvements once a year or sometimes even less frequently. The language has evolved more slowly than we would like, and release dates have been somewhat unpredictable for the users.

The main goal of the new date-driven release cadence is to accelerate the delivery of important language updates.

What are the changes in the new cadence?

There are three types of Kotlin releases: feature, incremental, and bug fix releases. However, changes will, for the most part, only affect feature releases. Below is a diagram of the new Kotlin release cadence.

Feature releases (e.g. 1.4, 1.5) will ship updates to the language twice a year– in spring and in autumn – starting from Kotlin 1.5, which is due in spring 2021. Feature releases will become smaller in terms of the changes they bring, and their release dates will be more predictable.

Incremental releases (e.g. 1.3.70, 1.4.20) will ship in between major releases. They will not include language changes, only compiler improvements (e.g. speedups) and tooling changes.

Bug fix releases (e.g. 1.3.71, 1.3.72) will possibly, but not necessarily, follow incremental releases. They mainly contain hotfixes.

Extra notes on the Kotlin IDE plugin

Nowadays, major changes in the Kotlin IDE plugin depend on the IntelliJ Platform more than on the Kotlin compiler. So, from now on, new versions of the Kotlin plugin will ship with every release of the IntelliJ Platform as well as with new versions of Kotlin.

At all times, the IDE support for the latest version of the language will be available for the two latest versions of IntelliJ IDEA and the latest version of Android Studio.

We are in the process of moving the Kotlin IDE plugin to the IntelliJ IDEA codebase to minimize the time it takes us to pick up platform changes, and also make sure that the IntelliJ team gets the latest Kotlin IDE fixes very quickly and dogfoods them efficiently. Also, it will be easier for us to keep the IDE support for Kotlin on par with Java. This is why we synchronize our release cycles.

Summary

Kotlin is evolving quickly and we’re keen to remove any obstacles preventing the team and the community from achieving their goals. Today we’ve introduced two major process improvements, and we believe they will speed up the language progress even more.

If you are interested in the Kotlin team’s plans and the projects we’re currently working on, you can find more information in the recently published Kotlin public roadmap.

Continue ReadingNew Release Cadence for Kotlin and the IntelliJ Kotlin Plugin

Kotlin 1.4 Released with a Focus on Quality and Performance

You can read this blog post in other languages:
日本語, Français, 한국어, Español, Português, Русский, 简体中文

Today we’re releasing Kotlin 1.4.0! Over the past years, we’ve been working hard on making Kotlin a programming language that is fun, enjoyable, and productive to work with. To continue our pursuit of this goal with this version of Kotlin, we put a lot of energy and effort into improving the performance and quality of Kotlin and its tooling. We are also excited to announce support for several new language features, including the long-awaited SAM conversions for Kotlin interfaces.

file

To help you get the most out of the changes and improvements introduced in Kotlin 1.4, we’re inviting all of you to the Kotlin 1.4 Online Event, where you will be able to enjoy four days of Kotlin talks, Q&As with the Kotlin team, and more – completely free.

Community and ecosystem

More than 5.8 million people have edited Kotlin code in the last 12 months, and the numbers are constantly growing:

file

We’re delighted to see how popular Kotlin is becoming! The numbers of active users – we’ll explain this metric in more detail in a future blog post – have been especially encouraging. Here, we are seeing a 1.5-fold increase over the previous year’s figures.

According to the StackOverflow Developer Survey 2020, Kotlin has climbed to 13th place among the most popular programming languages for professional developers, and we’re happy to see that Kotlin is one of the top 5 most loved languages.

Many companies have picked Kotlin as their language of choice, and are successfully using it on all platforms. We’re happy to see this tendency, and we’re tremendously grateful that so many of these companies have made case studies available for the community to read and learn from. Here are just a few amazing examples of software recently developed in Kotlin:

Our Kotlin communities are also growing rapidly. Over 30,000 Kotlin developers are now exchanging knowledge and supporting each other on Slack and Reddit, and more than 90,000 people follow our official Twitter account for tips, tricks, and announcements. With over 200 user groups worldwide, the Kotlin community is thriving and growing. We’re thankful to all of you for helping spread the word, sharing your knowledge, and supporting your fellow Kotlin developers. The warm, welcoming atmosphere you create is what makes exploring Kotlin together such a delightful experience. It wouldn’t be the same without you.

Kotlin 1.4 Online Event

We want to make sure that you have a great experience using Kotlin 1.4, and we want you to have a good idea of where we are taking the language next. This is why we are happy to invite all of you to our Kotlin 1.4 Online Event!

It consists of four days packed with knowledge about Kotlin and the future of the language and its ecosystem: We’ll discuss the new changes and improvements we made with Kotlin 1.4, and we’ll share our future plans for the language. Our Kotlin team members will answer your questions in daily Q&A sessions. Submit your questions in advance by tweeting them with the #kotlin14ask hashtag, or using this form.

The Kotlin 1.4 Online Event will be streamed on October 12–15, and you can register for free here:

Register for Kotlin 1.4 Online Event

We look forward to seeing all of you there!

Focusing on quality

Our main focus for this release was improving the overall development experience with Kotlin, including improved IDE performance and stability. Our goal is to make Kotlin users as productive as possible, and we focused on improving the things that are most important to users, so they feel even happier when using it!

We’ve reviewed and fixed more than 60 performance issues, including many that were causing IDE freezes or memory leaks. During the EAP phase for Kotlin 1.4.0, we gathered a lot of positive feedback indicating that the overall experience is now much more enjoyable!

When you are working with a project and open a large Kotlin file for the first time, you now see its content with highlighting much sooner. In most cases, highlighting is now 1.5-4 times faster:

We have also significantly improved the time it takes for autocomplete suggestions to appear. The following graph shows an overview of the average autocomplete response times that Kotlin users experience. The number of cases in which completion takes more than 500 ms has been cut nearly in half:

file

Note that these latest changes, including the code highlighting speed-up, require IntelliJ IDEA 2020.1+ and Android Studio 4.1+.

Performance improvements are an ongoing process, and we have many more enhancements planned, like continuing to work on eliminating freezing and making typing smoother. We’ve already started integration with the new experimental Kotlin compiler frontend that will make the IDE a lot faster. This is a huge task that requires many parts of the plugin to be rewritten, but it will boost performance in many areas of the IDE, including code completion, syntax highlighting, and compiler error reporting.

New IDE functionality

Our mission at JetBrains is to make software development a more productive and enjoyable experience, so we naturally want to make sure that the tooling surrounding Kotlin is excellent and makes coding Kotlin as easy as possible.

To make it easier for you to work with coroutines, and especially to pinpoint bugs in your concurrent applications, we’ve introduced the Coroutine Debugger. We’re going to expand on its initial feature set to provide the functionality most needed by the community, so please share your feedback with us using one of our channels or in the comments section below.

We are also introducing a new flexible Kotlin Project Wizard. This new wizard provides a single place for you to create and configure Kotlin projects of different types, making it easy to get started even with more complex structures such as multiplatform projects.

More than 40 new quick-fixes, intentions, and inspections have been added with Kotlin 1.4.0, and will be available exactly when you need them – when you modify your code, and press Alt+Enter to see what’s available in your specific context.

New compiler

For quite some time now, we’ve been working on a new Kotlin compiler that will advance the evolution of Kotlin in terms of performance and extensibility. The main goals for the new compiler are that it should be really fast, unify all the platforms that Kotlin supports, and provide an API for compiler extensions. We’re introducing new parts step by step, so that they reach the user as soon as possible. With Kotlin 1.4.0, we’re releasing several parts from this ongoing effort:

We’re actively working on a new frontend implementation, which will provide the biggest performance increase in the compiler pipeline. The frontend is the part of the compiler that parses the code, resolves names, performs type checking, and more, so it affects the IDE performance as well. A preview of it will be available in future releases, stay tuned!

Language features

Kotlin 1.4 comes with many new features:

Library improvements

Our general priority for the standard library is to improve consistency, both across different platforms and among the operations themselves. In this release, the Kotlin standard library gets new collection operators, delegated properties improvements, the double-ended queue implementation

ArrayDeque

, and much more.

You can use the standard library in “common” code – the code shared between different platforms, be they Android & iOS or JVM & JS. We’re gradually extending the common library and adding or moving missing functionality to it.

It is also no longer necessary to declare a dependency on the

stdlib

in any Gradle Kotlin project, whether you are targeting a single platform or working in a multiplatform project. Starting with Kotlin 1.4.0, this dependency is added by default.

We’re working on other parts of the Kotlin ecosystem:

Kotlin/JVM

We encourage you to try out the new Alpha Kotlin/JVM backend for your regular projects and share your feedback! Along with unifying the compiler pipelines, this effort will help us bring compiler extensions like Jetpack Compose to the Kotlin community more quickly.

Language features specific to Kotlin/JVM:

Kotlin/JS

Kotlin 1.4.0 comes with a new Gradle DSL and an Alpha version of the new Kotlin/JS compiler backend, among other features.

  • The new Gradle DSL adds support for configuring CSS and style loaders from the DSL, it includes various improvements related to npm dependency management and improves control over the Dukat integration.
  • The new Kotlin/JS compiler backend gives a taste of the future for Kotlin/JS. It includes optimizations and features such as the automatic generation of TypeScript definitions from Kotlin code, smaller binaries and bundles, a modernized way to expose Kotlin functionality to JavaScript, and more.

Kotlin/Native

Kotlin/Native got a significant number of new features and improvements, including:

The current automatic memory management implementation in Kotlin/Native has limitations when it comes to concurrency and we are working on a replacement for it.

An important focus for Kotlin/Native is making it seamless for Kotlin Multiplatform Mobile, but it’s not limited to this.

Kotlin Multiplatform

Making Kotlin a great multiplatform solution is one of our top priorities. We promised some important improvements at KotlinConf, and we’re happy to report on what we’ve delivered:

We’re working on an Android Studio plugin for running, testing, and debugging Kotlin code on iOS devices and simulators. The first public preview is going to be released very soon, so please stay tuned.

We’re soon going to release a bunch of materials created with the help of Kotlin community members explaining how you can use Kotlin Multiplatform Mobile (KMM) technology to target specifically mobile use-cases in which code is shared between Android and iOS.

Despite the major focus now being on mobile targets, the Web target for Kotlin Multiplatform is already actively used by JetBrains to build and ship JetBrains Space. Web target continues to be an important strategic investment for Kotlin.

More details

You can find detailed descriptions of new features on the Kotlin 1.4 What’s New page and documentation, and read more about migrating to Kotlin 1.4.

As in all major releases, some deprecation cycles of previously announced changes are coming to an end with Kotlin 1.4. All of these cases were carefully reviewed by the language committee and are listed in the Compatibility Guide for Kotlin 1.4.

How to help us improve Kotlin

The Kotlin plugin in IntelliJ IDEA and Android Studio can collect anonymized statistics about how you use its functionality. We kindly ask you to opt in to these statistics!

This anonymous data greatly helps us understand our users better, see what works, what is causing difficulties, and where we should direct our focus. To enable statistics, go to Preferences, open Appearance & Behaviour | System Settings | Data Sharing and activate the Send usage statistics checkbox.

Top issue reporters since Kotlin 1.3

We’d like to thank all the members of the community who helped us make this release better by reporting issues to YouTrack! We’ve made a list of the top 20 reporters and would like to thank them specifically:

Igor Wojda (145 issues); Louis CAD (87 issues); Marc Knaup (86 issues); AndroidDeveloperLB (83 issues); Robert Stoll (68 issues); Morgan Bartholomew (62 issues); Victor Turansky (54 issues); Guan Tianyi (51 issues); Scott Pierce (38 issues); Andreas Malik (37 issues); Steven Schäfer (37 issues); Björn Kautler (36 issues); Róbert Papp (34 issues); Toshiaki Kameyama (30 issues); Nicholas Bilyk (29 issues); Michael Bailey (26 issues); Jake Wharton (25 issues); Lamberto Basti (24 issues); Serge Pro (23 issues); Egor Andreevici (21 issues).

Start using Kotlin 1.4 right now

As always, you can try Kotlin online at play.kotl.in.

In Gradle and Maven, use 1.4.0 as the compiler version. See the docs for Gradle and for Maven.

IntelliJ IDEA and Android Studio automatically prompt you to update the Kotlin plugin to version 1.4.0. You can also open Preferences | Plugins and update the Kotlin plugin manually.

The command-line compiler can be downloaded from the GitHub release page.

You can use the following versions of the libraries published together with this release:

The versions of libraries from

kotlin-wrappers

(

kotlin-react

etc.) can be found in the corresponding repository.

The latest IDE performance improvements, including the code highlighting speed-up, require IntelliJ IDEA 2020.1+ and Android Studio 4.1+.

If you run into any problems with the new release, you can find help on Slack (get an invite here) and report issues in our YouTrack.

Thank you!

We’re really grateful to everyone who has tried out and given us feedback on the Kotlin EAPs and experimental features. We are developing the Kotlin language together with you, and making many design decisions based on your invaluable input. Keeping this fast and effective feedback loop going with the community is really important to help Kotlin become the best it can be!

We want to say a big thank you to all our external contributors whose pull requests were included in this release. You helped us make this release happen!

We’re grateful to all members of our community who are creating so many amazing things with Kotlin. Kotlin 1.4: One for all!

Continue ReadingKotlin 1.4 Released with a Focus on Quality and Performance

End of content

No more pages to load