Помимо того, что это лучший выбор для разработки под Android, он может предложить гораздо больше.

Если вы разработчик программного обеспечения или любой профессионал, работающий в ИТ-секторе, вы, вероятно, слышали о языке Котлин.

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

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

История

Впервые язык Kotlin был выпущен в 2011 году компанией JetBrains; если вы не знаете о них, сначала они были известны как создатели популярной IntelliJ IDEA, а теперь они также очень известны как создатели языка Kotlin.

Хотя их первый выпуск был в 2011 году, только в 2016 году был выпущен Kotlin v1.0, первый официальный выпуск, с которого JetBrains обеспечит обратную совместимость; Вы можете проверить схему управления версиями Kotlin здесь. Kotlin в настоящее время находится на версии 1.5, и в следующие сроки мы сможем сравнить цикл выпуска Kotlin с циклом выпуска JDK.

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

С другой стороны, цикл выпуска Kotlin также начинался как цикл, основанный на функциях, но JetBrains решила перейти на цикл, управляемый данными, начиная с версии 1.5 весной 2021 года.

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

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

Другой важной характеристикой этого нового языка было бы то, что он должен был иметь возможность взаимодействовать с языком Java, чтобы обеспечить медленное и безболезненное принятие нового языка. Благодаря этому, и особенно с учетом того, что Kotlin является языком с полностью открытым исходным кодом, он по-прежнему будет иметь доступ ко всей работе, проделанной сообществом Java Open Source за последние десятилетия.

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

В чем причина того, что Kotlin становится настолько популярным и широко применяемым в нашей отрасли? Давайте рассмотрим его основные характеристики, чтобы понять причины его популярности.

Простота и прагматизм превыше всего

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

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

Давайте кратко рассмотрим некоторые из них.

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

Kotlin - это мультиплатформенный язык, который может выполняться на разных поддерживаемых платформах; вы можете ориентироваться на различные среды выполнения, такие как JVM, Android, JS или многие другие, с использованием Kotlin / JVM, Kotlin для Android, Kotlin / JS и Kotlin / Native. Однако имейте в виду, что статус мультиплатформенного проекта все еще находится в состоянии Альфа; это означает, что он еще нестабилен, и вы можете ожидать некоторых проблем с переносом. Для получения дополнительной информации перейдите по этой ссылке.

Типы

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

Подробнее о типах Kotlin можно узнать здесь.

Создание нового экземпляра

Некоторые языки, такие как Java или C ++, требуют использования оператора «новый» для создания нового экземпляра объекта. Мы все к этому привыкли, но действительно ли это необходимо? Почему бы просто не вызвать конструктор?

Это именно то, что делает Kotlin, нам больше не нужно использовать new в Kotlin, вызова конструктора объекта достаточно для создания нового экземпляра.

Например, мы можем создать экземпляр объекта Order следующим образом:

val order = Order("id", 10, BigDecimal(12.5), OrderType.BUY)

Конец выступлений

Например, почему мы вынуждены писать точку с запятой в конце каждой строки на некоторых языках? Предоставление возможности записывать несколько операторов в одной строке не требуется и, возможно, не рекомендуется для удобства чтения, так почему бы не принять строку разрыва в качестве стандарта для представления конца оператора? Если вы разработчик Java или C ++, вы, вероятно, пропускали точку с запятой тысячи раз - подумайте о том, сколько времени было потрачено впустую. Kotlin не требует использования точки с запятой для закрытия оператора, хотя, если вы это сделаете, он все равно будет компилироваться.

Вывод типов и неизменяемость

Kotlin также сокращает количество подробностей, связанных с двойным объявлением типа переменных; Вывод типа позволяет нам просто объявить создание новой переменной, выводя тип из правой части оператора.

Еще одно улучшение с точки зрения объявления переменных состоит в том, что нам не нужно использовать какие-либо дополнительные модификаторы для объявления переменной как неизменной; Kotlin предоставляет всего два ключевых слова: var и val. Намного проще, чем на других языках, если вам нужна изменяемая переменная, используйте var; если вам нужна неизменяемая переменная, используйте val, так просто.
Например, следующий фрагмент будет разрешен, мы можем переопределить значение изменяемой переменной, определенной с помощью var.

var order: Order = Order("id1", 10, BigDecimal(12.5), OrderType.BUY)
order = Order("id2", 12, BigDecimal(15.5), OrderType.SELL)

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

val immutableOrder: Order = Order("id1", 10, BigDecimal(12.5), OrderType.BUY)
immutableOrder = Order("id2", 12, BigDecimal(15.5), OrderType.SELL) //Compilation error!

Классы данных

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

data class Employee(val id: String, val name: String, val age: Int)

Дилемма NullPointerException

Если вы разработчик Java, то наверняка столкнулись с проблемами, связанными с наличием null в качестве возможного значения для объекта или переменной; какое было бы простейшее решение этой проблемы? Здравый смысл подсказывает нам, что отказ от нулевых значений в первую очередь, вероятно, будет самым простым и безопасным решением; именно это и делает Котлин. Если вы попытаетесь присвоить объекту в Kotlin нулевое значение, вы получите ошибку компиляции, поэтому по умолчанию объекты не допускают значения NULL, вам нужно будет явно указать компилятору, что объект допускает значение NULL, чтобы разрешить значения NULL. Это здорово, не правда ли? Еще раз, простота и безопасность превыше всего.

val order: Order = null //Compilation error!val nullableOrder: Order? = null

Строковая интерполяция

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

val name = "John"
val surname = "Smith"
println("My name is $name $surname")

Деструктуризация объекта

Kotlin предлагает нам одну из самых крутых функций, доступных в JavaScript, - деструктуризацию объектов. Мы можем сделать что-то вроде этого:

val (name, age) = Employee("id1", "John", 35)

Это здорово, хотя, к сожалению, это можно сделать только с классами данных. Если мы хотим использовать интерполяцию строк без классов данных, мы вынуждены реализовать операторы component1 () и component2 () в нашем объекте Order, что лично меня не очень устраивает.

Например, если бы наш класс Employee не был классом данных, мы должны были бы сделать следующее, чтобы иметь возможность использовать деструктуризацию объекта:

class Employee(val id: String, val name: String, val age: Int) {
  operator fun component1(): String = name
  operator fun component2(): Int = age
}

Вы также можете использовать расширения Kotlin для реализации необходимых операторов для класса Employee:

private operator fun Employee.component1(): String = name
private operator fun Employee.component2(): Int = age

Вам должно быть интересно, почему мы должны это делать, чтобы иметь возможность использовать деструктуризацию объекта; Фактическая причина в том, что компилятор Kotlin компилирует класс данных в следующий, если вы декомпилируете соответствующий файл класса:

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

// IntelliJ API Decompiler stub source generated from a class file
// Implementation of methods is not available
package com.coding.kotlin
public final class Employee public constructor(id: kotlin.String, name: kotlin.String, age: kotlin.Int) {
  public final val age: kotlin.Int /* compiled code */
  public final val id: kotlin.String /* compiled code */
  public final val name: kotlin.String /* compiled code */
}

Одна вещь, которую деструктуризация объектов Kotlin прекрасно решает, - это сложный и беспорядочный способ, который Java предоставляет для итерации по записям в Map. В Kotlin мы можем просто делать следующее:

for ((key, value) in myMap) {
  println("$key, $value")
}

Это определенно намного лучше и по-прежнему так же быстро!

Аргументы по умолчанию

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

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

Например, если мы определим значение по умолчанию для нашего типа заказа:

constructor(userId: String, quantity: Int, price: BigDecimal, type: OrderType = OrderType.BUY)

Теперь мы можем создать экземпляр объекта Order без указания типа заказа:

val buyOrder = Order("id", 10, BigDecimal(13.2))

Именованные аргументы

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

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

Например:

val sellOrder = Order("id", type = OrderType.SELL, price = BigDecimal(3.0), quantity = 1)

В целом у нас меньше жесткости и более выразительный и читаемый язык.

Асинхронное программирование - сопрограммы и каналы

Kotlin использует другой подход к таким языкам, как Java, для запуска многопоточных приложений; способ работы Kotlin очень похож на то, что делает Golang.

Golang предоставляет горутины и каналы так же, как Kotlin предоставляет сопрограммы и каналы.

Чтобы помочь вам понять, почему так важны сопрограммы, я кратко расскажу о том, как работают текущие потоки Java. Текущая реализация потоков Java полагается на потоки ядра ОС, и это создает несколько проблем:

  1. Потоки очень тяжелые, главным образом потому, что, когда поток приостанавливается, его собственный стек вызовов и его стек вызовов Java должны быть сохранены или извлечены.
  2. Планировщик ОС не может различать потоки, чтобы иметь возможность сгруппировать их для каждого пользователя или единицы работы. Это означает, что два потока, обрабатывающие одни и те же данные, скорее всего, будут выполняться разными процессорами.

Это приводит к большой проблеме: переключение контекста между потоками обходится довольно дорого и снижает производительность, поскольку передача данных между процессорами обходится дорого. В идеале мы бы хотели, чтобы эти два связанных потока обрабатывались одним и тем же процессором, но это невозможно с помощью планировщика ОС. Это подводит нас к решению этой проблемы Kotlin: сопрограммам Kotlin.

Сопрограммы Kotlin - это очень легкие компоненты, используемые для одновременного выполнения задач; они очень малы по размеру по сравнению с потоками Java и, в отличие от них, управляются не операционной системой, а средой выполнения Kotlin. Это означает, что мы можем создать их множество, и теперь стало возможным создание «потока» для каждого пользователя или транзакции, в отличие от ограничений Java из-за того, что потоки Java очень тяжелые.

Давайте посмотрим на пример сопрограмм, чтобы лучше их понять:

val start = System.nanoTime()
runBlocking(Dispatchers.Default) {
   (1..2_000_000).map { index ->
       launch {
           delay(100)
           println("I'm a lightweight thread number $index! running on ${Thread.currentThread()}")
       }
   }
}
println("Done in ${(System.nanoTime() - start) / 10e09} seconds!")

В этом примере мы создаем 2 миллиона «потоков», каждый из которых имитирует задержку в 100 миллисекунд. Эти потоки будут выполняться одновременно, и они будут обрабатываться средой выполнения Kotlin. Kotlin позволяет нам без проблем создавать огромное количество потоков; это абсолютно невозможно в Java, вам потребуется пул потоков ограниченного размера и повторно использовать потоки для различных вызовов, поскольку их создание и хранение в памяти обходятся дорого.

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

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

Это гораздо более эффективный и простой подход для работы с параллелизмом и параллелизмом; вместо того, чтобы делиться ресурсами, заинтересованные стороны общаются между собой для достижения общей цели!

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

Мы определенно могли бы продолжить гораздо дольше, показывая все существующие приятные функции, которые придумал Kotlin, но этого, вероятно, достаточно, чтобы дать вам хорошее представление о радикальном изменении мышления, которое этот язык принес нам в мир JVM. Языковой дизайн, созданный разработчиками, ориентированный на производительность, простоту и удобство, чтобы мы могли получать удовольствие от того, что мы делаем. Битва против шаблонного кода и ненужного беспорядка.

Это тот вид прагматизма, к которому стремится Kotlin - очень маленькие вещи, которые сами по себе могут показаться незначительными, но в совокупности они имеют огромное значение с точки зрения производительности!

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

В настоящее время действительно хорошее начало

Если вы посмотрите на рыночные тенденции и комментарии разработчиков в социальных сетях, вы увидите, что Kotlin был очень тепло встречен сообществом. Котлин стал для многих глотком свежего воздуха; его радикальный и очень умный подход имеет большое значение.

На изображении ниже вы можете увидеть интерес к Kotlin во всем мире согласно Google Trends:

Предоставление того, что почти похоже на совершенно новый язык, но в то же время с полной совместимостью с языком Java и возможностью использовать JVM в качестве среды выполнения, означало огромное преимущество, и это был очень разумный шаг. Хотя существуют и другие языки JVM, способные взаимодействовать с кодом Java, безупречная совместимость Kotlin в некоторых случаях намного превосходит другие, а в тех случаях, когда уровень взаимодействия аналогичен, другие характеристики языка склоняют чашу весов в пользу Kotlin.

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

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

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

Хотя Kotlin позволяет более плавно переключаться с Java, стоит отметить, что переход на новый язык в рабочей среде никогда не бывает легкой задачей; вам нужно будет составить соответствующий план с четко определенными целями. Очень важно понимать, чего мы хотим достичь, почему мы делаем выбор, который делаем, и стараться привлечь всех, включая руководство. Нам также необходимо будет рассмотреть, каковы риски, прежде чем приступить к миграции; риски как потенциальный недостаток опыта в команде с новым языком или трудности с привлечением новых разработчиков в команду.

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

Один важный аспект, который следует учитывать при переходе на Kotlin, заключается в том, что Kotlin стал первоклассным гражданином в Spring framework после того, как Pivotal (теперь часть VMWare Tanzu) решил начать поддержку Kotlin с версии 5.0 в 2017 году. Это позволяет использовать функции Kotlin в интеграции Spring, получить более лаконичный и выразительный код при работе со Spring и Kotlin и испытать более плавный переход с Java на Kotlin для всех этих проектов, использующих среду Spring.

Еще одним большим шагом в освоении Kotlin стал его огромный успех в индустрии мобильной разработки. В 2017 году Google впервые объявил о поддержке Kotlin для разработки Android, а затем, всего два года спустя, Google публично заявил, что его новым предпочтительным языком для разработки Android теперь является Kotlin, что стало огромным шагом к широкому внедрению Kotlin среди разработчиков в нашей отрасли. Это означает, что теперь мы можем использовать тот же язык и те же библиотеки для серверных и мобильных приложений, что и для Java, но писать более лаконичный, выразительный и элегантный код и использовать такие классные языковые функции, как защита от нуля или сопрограммы.

Как мы видим, настоящее Котлина выглядит ярким, но какое будущее ждет Котлина?

Его будущее

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

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

Хорошими примерами этих отсутствующих функций могут быть записи Java, в которых все еще есть предварительные версии, и нам придется подождать не менее 6–12 месяцев, прежде чем мы сможем их безопасно использовать, или Project Loom Java. Java-потоки были проблемой в течение очень долгого времени, и, несмотря на это, эта работа не начиналась до конца 2017 года. Хотя они добиваются прогресса и есть несколько сборок с ранним доступом, доступных для начала тестирования, это еще далека от завершения.

С другой стороны, JetBrains удалось подготовить что-то к производству в гораздо более разумные сроки; это одна из причин, по которой некоторые разработчики теряют терпение к Java и принимают решение перейти на Kotlin.

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

Все мы знаем, что Kotlin в основном используется на стороне сервера и в разработке для Android, но еще более интересным Kotlin делает то, что он был разработан как многоплатформенный язык и выходит за рамки нашего традиционного понимания мультиплатформенности с точки зрения JVM-мира. Посмотреть.

Мы можем, например, использовать Kotlin / JS для преобразования нашего кода в JavaScript, имея возможность писать веб-приложения или даже приложения React! Не вдаваясь в подробности, я думаю, что это могло бы принести много преимуществ для разработки полного стека, но, прежде всего, это могло бы заполнить существующий пробел между внутренней и внутренней разработкой, что могло бы улучшить ситуацию в будущем.

В дополнение к этому, мы также могли бы использовать Kotlin / Native для написания приложений на Kotlin на платформах, где запуск JVM невозможен или нежелателен (встроенные устройства, iOS и т. Д.), Что может быть полезно в некоторых случаях использования.

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

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

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

Я также вижу, что Kotlin поддерживает более динамичная и открытая часть сообщества, многие из которых жаждут изменений в мире JVM!

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

JetBrains доказала свой успех с IntelliJ IDEA, став любимой IDE среди разработчиков во всем мире, потому что они понимают разработчиков и их потребности. Это и будет краеугольным камнем их успеха с Kotlin - поймите своих «клиентов», и им понравится ваш продукт.

Мы также увидели, что количество компаний, заинтересованных в Kotlin или сотрудничающих с JetBrains, росло за последние несколько лет. Например, Bellsoft и JetBrains договорились о стратегическом сотрудничестве в 2019 году, в рамках которого Bellsoft предоставляет исправления безопасности и критические обновления для среды выполнения JetBrains, ответвления JRE, используемого во всех языковых IDE. Это те же обновления и тот же процесс, что и для собственного дистрибутива BellSoft под названием Liberica JDK. Это одна из причин, по которой я рекомендую использовать Liberica JDK с Kotlin из-за их тесных взаимоотношений и сотрудничества.

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

С точки зрения роста, динамичная и быстро развивающаяся среда, предоставляемая такой компанией, как JetBrains, может стать очень важным фактором в ближайшие годы. Как я упоминал ранее, я думаю, что JetBrains знает, чего хотят разработчики, они очень хорошо понимают разработчиков и доказали это, создав самую популярную IDE за многие годы. Этот важный опыт и их четкая решимость в достижении своих целей могут стать решающим фактором большого успеха Kotlin в долгосрочной перспективе. Кто знает, может, пора все-таки порвать с прошлым и сделать ставку на будущее!

Заключение

Подводя итог, я думаю, что будущее Kotlin будет зависеть от того, насколько готово и непредвзято сообщество сделает твердую ставку на Kotlin и разорвет свои связи с другими языками. Учитывая красоту и простоту языка и его полную совместимость с Java, я не вижу явной причины не дать ему шанс. Kotlin - это язык, который может повысить продуктивность команды и читаемость кодовой базы; Кроме того, мы можем делать это постепенно и с минимальными рисками.

Эта статья изначально была опубликована на https://theboreddev.com