Практическое применение Kotlin в стартапах и энтерпрайзе

Disclaimer: Я не имею никакого отношения к JetBrains, не получаю денег от продвижения Kotlin или от написания данной статьи. Весь материал — это лишь отражение моего личного опыта.


Выбор того или иного языка (и вообще любого инструмента) как правило продиктован как объективными, так и субъективными факторами. В каждом проекте могут быть свои особенности, влияющие на выбор. Я далек от того, чтоб устраивать очередной холивар на тему какой язык круче — языков много и у каждого своя ниша. Однако, на мой взгляд выбор между Kotlin и Java более определенный, поскольку Kotlin покрывает все возможности Java и добавляет много дополнительного функционала и сахара.



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


В этой публикации я собираюсь объяснить свою позицию, а заодно опишу некоторые особенности перехода с Java на Kotlin как в условиях стартапа, так и в условиях крупного энтерпрайз-проекта.


Kotlin против Java


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


На мой взгляд, Java зародилась как мощный ответ прежде всего C++. Поэтому в ней чувствуется сильное его влияние со всеми его недостатками. Проблема в том, что за 25 лет существования Java, она продемонстрировала значительную консервативность по сравнению с другими языками. В то время как множество языков экспериментировали с ключевыми словами типа async, с пунктуацией языка (точки с запятой, скобки и пр.), Oracle хранила исключительную верность "традиционным принципам", что привело лишь к моральному устареванию самого языка.


Печально то, что разрыв лишь нарастает, несмотря на попытки его сократить со стороны Oracle. Например, дата-классы в Kotlin появились в самых ранних версиях, а некий их аналог в Java появился лишь в 14 версии, полагаю, как раз под давлением конкуренции с JetBrains.


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


Если вам в вашем проекте требуется "возить лес в Сибири" вдали от селений и с полным отсутствием бензина, то, вероятно, паровоз вам действительно подойдет лучше. Но большинство проектов все же находятся не в столь экзотических условиях. Поэтому тот факт, что на Kotlin проект получается раза в 2-3 компактнее, более легкочитаемый, более надежный в плане защиты от NullPointerException, должен стать серьезным аргументом. Именно эти особенности и позволяют Kotlin снижать в 2 раза время разработки и количество багов, а в итоге, стоимость создания и владения программным продуктом.


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


  1. Множество элементов, сокращающих бойлерплейт: data class, getters&setters — в разы сокращает количество кода.


  2. Более продуманная и юзабельная структура классов: вместо HashMap, например, Map (иммутабельный) и MutableMap (мутабельный) — позволяет с легкостью входить в язык новичкам и концентрироваться на бизнесовой постановке, а не на способах реализации.


  3. Прямо из коробки идут различные защиты, например от null:


    var str: String = ""
    str = null // Здесь будет ошибка компиляции, а не runtime
    var nullableStr: String? = null // а так можно

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


  4. На уровне языка идет поддержка асинхронных операций, которые существуют в Python и JS ES6 — приводит к упрощению работы с асинхронными и многопоточными операциями по сравнению с Java.


  5. Kotlin Multiplatform — возможность компиляции программ на Kotlin одновременно для JVM, JS, Native (C/C++, Object C) — допускает снижение дублирования кода, более легкую интеграцию с фронтендами и более оптимальную разработку в архитектуре Serverless.


  6. Domain Specific Language (DSL) — дает компактную и легкочитаемую замену билдерам.



Проблемы перехода на Kotlin


При обсуждении проекта с командами, возникают одни и те же вопросы по внедрению Kotlin. Давайте пройдемся по ним.


Где взять Kotlin разработчиков?


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


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


Сколько нужно времени для подготовки разработчиков?


Kotlin разрабатывался на базе Java и совместим с ним на 100%. Поэтому для перехода на него не обязательно проходить какие-то специализированные курсы. Начать разрабатывать на Kotlin можно с первого дня. Базовых отличий не так много между языками. Например, if работает и там, и там практически одинаково, дополнительно в Kotlin его можно использовать в виде выражения:


val x: Int = if (a == 1) 2 else 3

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


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


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


Как быть с легаси кодом?


Kotlin полностью интероперабелен с Java, что позволяет прямо в программе на Kotlin использовать код, написанный в Java. Также в саму Intellij Idea включен плагин, который на лету умеет конвертировать куски кода (либо весь файл) из Java в Kotlin. Надо понимать, что качество автоконвертации не сравнится с работой человека, но тем не менее, инструмент очень полезный.


Также Kotlin позволяет писать код одновременно на Java и Kotlin в одном модуле. Для этого можно настроить сборщик либо на расширения, либо на директории, разнеся их в src/main/java и src/main/kotlin. Тут опять нужно знать о нюансах: код из Java легко подхватывается в коде на Kotlin, но для обратной совместимости приходится прилагать определенные усилия. Например, по умолчанию в Kotlin вместо статических методов используются объекты-компаньоны и для экспорта в Java требуется применить аннотацию @JvmStatic.


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


У нас стартап, зачем нам Kotlin?


Довольно часто для стартапов применяется даже не Java, а такие языки как PHP, Python, JavaScript (NodeJS). В каких-то случаях это может быть оправдано, но надо иметь в виду следующее. Перечисленные языки могут себя неплохо показать для прототипирования, но из-за отсутствия строгой типизации, они меньше подходят для долгосрочных, крупных проектов. Просто потому, что строгая типизация позволяет избегать множества ошибок на этапе даже не компиляции, а на этапе написания кода в IDE. Ошибки, допущенные из-за отсутствия проверки типов, выливаются в простои в боевом режиме, приводя к убыткам. Поэтому вам нужно тщательно взвесить все выгоды от быстрой разработки на языках без строгой типизации и убытки от их применения в продуктовом режиме.


Довольно часто бытует мнение, что первую продажу можно сделать на каком-нибудь PHP, а затем мигрировать на Java/Kotlin. Мой опыт говорит, что сделать первую продажу можно вообще без кода хоть на PHP, хоть на Kotlin. Но времени для перехода с одного языка на другой на практике никто не даст при развитии стартапа. Каждый день будут задачи, которые нужно сделать вчера.


Безусловно, на любом языке можно написать плохо. Но PHP, Python, JS дают гораздо больше возможностей для низкокачественного кода, чем Java/Scala/Kotlin. И чем хуже изначально написанный код, тем хуже он поддерживается дальше, приводя к еще большим костылям. Я сталкивался со стартапом, который стартовал нормально, но за 7 лет своей работы получил совершенно нечитаемый и неподдерживаемый код на Python. Ситуация оказалась патовой: его нельзя было просто так закрыть из-за наличия обязательств, и нельзя было продолжить развивать из-за необходимости полностью переписать проект, на что бюджета уже не было.


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


Особенности разработки на Kotlin


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


Ненулевые переменные и свойства класса


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


data class SomeClass(
    var x: String = "",
    var y: Int = -1
) {
    companion object {
        val NONE = SomeClass()
    }
}

, который и используется при инициализации в качестве значения по умолчанию вместо null.


Существует множество случаев, когда нам просто необходимо делать свойства нулевыми. Например, в API или в хранилище мы не можем быть уверенными, что нам придет всегда non-nullable значение. Как раз здесь и играет свою роль DDD (domain driven design). Мы для отправки данных или для сохранения делаем отдельные DTO-классы, которые содержат в себе нулевые поля, а в рабочие модели мы их мапим со всеми проверками:


data class StorableObject(
    var id: String? = null,
    var data: String? = null
) {
    // Место размещения мапера зависит от задачи
    constructor(wm: WorkModel): this(
        id = wm.id.takeIf { it != -1 }?.toString(),
        data = wm.data.takeIf { it.isNotBlank() }
    )

    // Место размещения мапера зависит от задачи
    fun toWorkModel(): WorkModel = WorkModel(
        id = id?.toInt() ?: -1,
        data = data ?: ""
    )
}

Таким образом, простое использование Null-safety в Kotlin стимулирует нас применять практику DDD, что в свою очередь делает наш код более гибким, защищенным от изменений API или внутренней логики.


Kotlin Multiplatform (KMP)


KMP — это довольно мощное средство и его стоит использовать в проектах при интеграции с JS и Native компонентами системы. На практике, KMP вполне неплохо себя показывает при описании API для потребления Single Page Application (SPI) типа React, Angular, Vue, а также мобильными приложениями под Android и iOS.


Но лично я предпочитаю разрабатывать фронтенд на Dart/Flutter, а с этим фреймворком простой интеграции через KMP пока не существует. Интеграцию между бэкендом на Kotlin и фронтендом на Dart можно реализовать с использованием OpenAPI, AsyncAPI, gRPC и других кодогенераторов.


На бэкенде KMP может быть применен, например, при использовании Serverless архитектуры, в том числе Google Cloud Functions, Yandex Cloud Functions, AWS Lambda и др. аналогов. Особенность бессерверных архитектур в том, что в них важна скорость старта приложения. Поэтому код на Python или NodeJs может показывать гораздо более низкое время отклика, чем на JVM. Использование KMP позволяет компилировать код в JavaScript или в Native executable, что вполне решает проблему быстрого старта.


Недостатки Kotlin


Наверное есть какие-то недостатки более бытового характера. Но для меня самым существенным недостатком является отсутствие фронтенд-фреймворка для Kotlin. Ktor, при всех его преимуществах, не достиг уровня фронтенд-фреймворка. Я как-то видел набор в Jetbrains фронт-разработчиков и думаю, что вскорости такой фреймворк будет анонсирован. Однако, на сегодняшний день на фронтенде я предпочитаю использовать Google Flutter, который использует язык Dart. Возможно для кого-то окажется более приемлемым переход на Dart как на фронтенде, так и на бэкенде вместо Котлина.


Заключение


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


  1. Kotlin — это действительно мощный инструмент, который превосходит классическую Java по многим параметрам. Поэтому я ожидаю, что в ближайшие 5 -10 лет произойдет существенное вытеснение им последней с рынка.
  2. Перевод реальных проектов на Kotlin не создает непреодолимых препятствий, наоборот, его уместно осуществлять на легаси-проектах, так и новых; как в корпорациях, так и в стартапах.
  3. При том, что переход на Kotlin довольно прост, недостаточный опыт чреват Java-стилем, что неэффективно. Для более полноценного использования этого инструмента, рекомендую получение опыта, привлечение экспертов, либо прохождение практических курсов разработчиками.
  4. Использование Kotlin может заметно влиять на архитектуру проекта, делать ее более стройной, а также позволяет применять техники, которые неприменимы в Java, в частности Kotlin Multiplatform.
  5. Пока не существует достаточно мощного фронтенд-фреймворка на Kotlin. Кто-то может предпочесть Котлину Dart, который можно использовать одновременно на всех платформах как на фронтенде, так и на бэкенде.

Similar posts

Ads
AdBlock has stolen the banner, but banners are not teeth — they will be back

More

Comments 128

    0
    Ktor, при всех его преимуществах, не достиг уровня фронтенд-фреймворка

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

    Фронтенд фреймворка действительно нет такого, чтобы был сравним с react, angular, vue, хотя для первого есть офф. обертка. Имхо разработчикам языка надо больше времени уделять javascript, это может невероятно сильно популяризировать язык. Пока ощущения двояки, вроде работает, вроде есть минимизация stdlib, вроде есть транслятор типов из typescript, но когда подключаешь сторонние библиотеки на javascript, чувствуешь боль от того, что для каждой (99% из 100) нужно писатьгенерировать типы и весь этот boilerplate код таскать в одной папке с исходниками (который, кстати, устаревает быстрее, чем комментарии). По-сути это работа авторов библиотек, но они пока не заинтересованы в написании типов на kotlin, жалко
      0
      По-моему, он позиционируется больше как мультиплатформенный фреймворк для клиент-серверных приложений, и если есть что-то из фронтенда, то это только голый html, css

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

      Имхо разработчикам языка надо больше времени уделять

      Там много еще недоделок, но дело движется…
        +1
        Kotlin-React ничуть не хуже простого React, обёртки добываются из TypeScript-овских при помощи Dukat (да, увы, готовых нет и вряд ли появятся в ближайшем будущем).
        В целом, на Котлине вполне успешно можно писать фронтенд, при этом используя общие с бэкендом классы модели и всякие там утилитные методы, типа валидаций и преобразований из варяг в греки.
        Минус — жирный, даже при использовании DCE и сжатия, js рантайм, тут надо осторожно — сейчас это приемлемо для многих приложений, но не для всех.
          0
          общие с бэкендом классы модели

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

            +2
            Да, конечно, речь идёт о DTO, которые летают между бэком и фронтом/мобилами (мы используем Kotlin MPP).
            Мешает или помогает один язык и там и там — это вопрос, не имеющий, кмк, однозначного ответа. Такой язык как Котлин — нам помогает.
              +1
              По моему опыту, на KMP удобнее делать интерфейсную логику доступа к бэку для фронта. Удобно же когда один раз сделал ее и разные фронты пользуются одним кодом.
              Менее очевидно и более спорно использовать его для генерации внутренних моделей, которые могут включать логику. Например, на транспортном DTO расчет ФИО из Ф, И, О будет избыточным, но для внутренней модели это вполне нормально.
              Ну и еще одно применение. Фронт бывает не только SPA. SSR часто делают на ноде, но ничто не мешает делать его на Kotlin — какая разница на чем шаблоны заполнять? В этом случае логику действительно можно будет шарить между тем же Реактом и SSR-ным бэкендом.

              А вообще, новые возможности могут значительно повлиять на применяемые практики программирования. Возможно, наш предыдущий опыт мешает увидеть какие-то новые подходы, которые могут стать преобладающими на рынке.
          +5
          Таким образом, простое использование Null-safety в Kotlin стимулирует нас применять практику DDD

          Сильное заявление...


          Возможно для кого-то окажется более приемлемым переход на Dart как на фронтенде, так и на бэкенде вместо Котлина.

          Попробовал я как-то дарт для бэка. Не советую – дарт еще менее готов для бэка, чем котлин для фронта.

            +9

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


            Null safety вещь конечно хорошая, но она не дружит с Java optional и поэтому возникают очень странные ситуации, когда не получается воспользоваться elvis оператором на пустом месте. К тому же есть в этой safety могут быть дыры.
            Kotlin multiplatform на бумаге красивая идея, но по факту я вижу в репозитории различные пакеты типа ktor-client-jvm, ktor-client-native, и т.д, что как бы прямо говорит, что никакой мультиплатформенности на самом деле нету, приходится копипастить несколько вариантов кода под разные платформы.
            В языке много сахара, но при этом не хватает ортогональности, те же data class это по сути сахар, в более сильных, с точки зрения системы типов, подобные абстракции делаются просто над обычными типами данных без необходимости в новых ключевых словах. В целом, хочу сказать, что ключевых слов в языке реально много, это как раз косвенно свидетельствует о том, что в языке много решений каких-то частных проблем вместо более глубокой проработки самого дизайна языка. Это зачастую приводит к тому, что приходится много частных случаев выучивать.
            Еще конечно гигантскую боль приносят Java аннотации и динамическая рефлексия. Это все игнорирует напрочь систему типов, многие проблемы как-то случайно обнаруживаются уже в момент запуска программы, хотя казалось бы, программист предоставил достаточно информации компилятору, чтобы тот проверил соответствие типов во время компиляции.
            Хуже того, бывают вообще трудноуловимые проблемы, когда Idea так невзначай тебе подставляет аннотацию с тем же именем, но из другого пакета, в результате они ну не совсем сходятся, но программа даже не падает, она просто в каких-то кейсах имеет неправильное поведение. Это прямо в худших традициях сишного UB. То есть, грубо говоря, вся система аннотаций полностью отменяет все преимущества статической типизации.
            Ах да, попробуйте прикрепить десериализацию к sealed data class'ам и порадуйтесь тому, как она прекрасно "работает", а главное отметьте момент, когда вы об этом узнаете.
            Опять же, как можно считать язык современным, если в нем можно лишь делать extension методы, но нельзя имплементить интерфейсы.
            Еще хочу отметить, что иногда очень удивляют тулы типа ktlint, у которого, когда его используешь через maven плагин, и когда просто в виде команды ktlint --format, отличаются представления о лексикографическом порядке импортов.
            Да и в используемых библиотеках часто наблюдал устаревшие туториалы и отсутствие нормальной документации, есть ли вообще в Kotlin экосистеме аналог docs.rs вообще, я ничего подобного не увидел?
            То есть язык конечно исправил многие проблемы Java и выглядит как-то получше, но это можно сравнить скорее с косметическим ремонтом, фундаментальные проблемы как были, так и остались, поэтому по настоящему современным ЯП ему не стать.

              0
              Я соглашусь, что какие-то проблемы действительно существуют, какие-то были в определенных версиях, но исправлены, с третьими я бы не согласился. Но речь сейчас не об этом. Котлин объективно превосходит Яву в бизнесовой разработке по скорости разработки и по дальнейшей поддержке продукта. Это объективно измеримая величина.
              Недостатки у Котлина есть, как и у любого другого сущего элемента в реальном мире. Но, когда стоит вполне бизнесовая постановка, под нее выделен вполне определенный бюджет и стоит вопрос лишь на чем разрабатывать, то вариантов на сегодня все же не так много.
              И по моему опыту, Котлин показывает более высокие результаты, по крайней мере в сравнении с Явой.

              Нисколько не претендую на истину, если предложите какую-то другую достойную альтернативу, с удовольствием изучу вопрос.
                +1
                > Это объективно измеримая величина.

                Можно узнать, есть ли где то результаты замеров? :)
                  –2
                  Сами для себя тестировали. Про публичные исследования не знаю.
                    +1
                    Ну просто это как раз и интересно. Расскажите про своё тестирование и результаты. Иначе заявления что «объективно измерили» звучат конечно же воспринимаются читателями как пятничный наброс.
                  +1
                  Хотелось бы больше услышать, про
                  обьективно превосходит
                  , какая статистика была собрана, по каким именно метрикам превосходит и так далее
                    0
                    Это было не научное исследование :) Для себя проверяли.
                    Просто один и тот же разраб тупо сделал DTO на Java, потом на Kotlin.
                    Ну за сколько человек набивает 4 килобайта Явовского кода в сравнении с 300 байтами на Котлине?
                    Естественно, что когда идет более сложный код, там все хитрее и уже больше играет по времени сама проблема нежели язык.
                      +3
                      Просто один и тот же разраб тупо сделал DTO на Java, потом на Kotlin.


                      Мы же знаем, что у всего есть цена. Нужно учитывать контекст задачи. Вот например можно почитать, во что это выливается когда есть дополнительные требования.
                  +1
                  Null safety вещь конечно хорошая, но она не дружит с Java optional и поэтому возникают очень странные ситуации, когда не получается воспользоваться elvis оператором на пустом месте. К тому же есть в этой safety могут быть дыры.

                  Лично меня больше раздражает, что вместо того, чтобы сделать нормальные сумм-типы (да, я в курсе про sealed classes, это не то) и сделать библиотечный класс Optional<T>, разработчики предпочли закостылить optional на уровне языка, получив:


                  1. Неортогональный синтаксис для объявления нуллабельных типов и операций над значениями таких типов.
                  2. Невозможность вкладывать нуллабельные типы друг в друга, что плохо сказывается на обобщённом коде.
                  3. Разбор нуллабельных значений происходит через через специальные if-ы и smart cast-ы и, т. е. условное переприсваивание типа того же идентификатора вместо привязывания типа к новому идентификатору. Мало того, что тайпчекинг каким-то раком оказывается завязан на анализ потока исполнения, так ещё и сами проверки нужно делать достаточно тупыми, чтобы компилятор понял.
                    +1
                    Лично меня больше раздражает, что вместо того, чтобы сделать нормальные сумм-типы

                    В Arrow скоро обещают на этот счет очень интересные штуки сделать.


                    сделать библиотечный класс Optional<T>

                    Можно взять тот же Arrow и получать optional + все остальные плюшки ФП. Котлин все-таки не чисто функциональный язык, поэтому текущее решение мне кажется вполне себе хорошим компромиссом между safety и порогом входа.


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

                    А что с этим не так?


                    Разбор нуллабельных значений происходит через через специальные if-ы и smart cast-ы и, т. е. условное переприсваивание типа того же идентификатора вместо привязывания типа к новому идентификатору.

                    Или я не понял, или в чем проблема привязать к новому идентификатору?


                    val nullable: String? = smth()
                    val nonNullable = nullable ?: return

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

                    С контрактами вроде поинтереснее становится в этом плане.

                      0
                      Можно взять тот же Arrow и получать optional + все остальные плюшки ФП.

                      Можно. Только проблема в том, что нативными нуллабельными типами пользуются все, а Arrow — далеко не все, и непонятно, изменится ли это.


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

                      Так это, наоборот, повышает порог входа. Вместо того, чтобы учить Optional как частный случай сумм-типов/sealed class, новичкам приходится учить специальный синтаксис: для объявления нуллабельных типов, для вызова методов на типе внутри нуллабельного, для разворачивания значений (двух видов) — который используется только для этого и больше ни для чего, и который нельзя использовать для своих типов.


                      Или я не понял, или в чем проблема привязать к новому идентификатору?

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

                        +3
                        Вместо того, чтобы учить Optional как частный случай сумм-типов/sealed class

                        Т.е. вы считаете, что ADT и монады понять проще, чем nullable?.doSomething()? Все-таки Optional становится действительно полезен, если он используется в совокупности с остальными приемами ФП. В императивном коде nullable?.doSomething() гораздо проще и понятнее для новичков, чем какой-нибудь optional.map { it.doSomething() }.


                        Синтаксис с ? уже получил достаточное распространение в других языках – Swift, TypeScript, Dart; в то время как Optional еще не так знаком новичкам. В результате я видел конструкции типа:


                        val x = optional.getOrElse { null }
                        x?.doSomething()

                        тип, приписанный значению, зависит от того, в какой ветке условного оператора он находится. Это и затрудняет чтение кода

                        Возможно, дело привычки. Мне наоборот кажется проще – не надо вводить новую переменную и держать ее в голове. В IDE smart casting выделяется цветом, на код ревью в GitHub – если нет ? и компилятор пропустил – значит тип приведен, на это можно вообще не обращать внимания. Но если это кажется менее читаемым – можно просто запретить на уровне команды, и вводить доп. переменную.

                          +2
                          Т.е. вы считаете, что ADT и монады понять проще, чем nullable?.doSomething()?

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

                            –1
                            ADT — да, проще. Именно потому, что это общий механизм

                            Ну по такому принципу и общую теорию относительности должно быть проще понять, чем законы Ньютона :)

                              0

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

                    +2
                    Kotlin multiplatform на бумаге красивая идея, но по факту я вижу в репозитории различные пакеты типа ktor-client-jvm, ktor-client-native, и т.д, что как бы прямо говорит, что никакой мультиплатформенности на самом деле нету, приходится копипастить несколько вариантов кода под разные платформы.

                    Но ведь так и должно быть. Общая логика в common, детали реализации в платформозависимые модули. Как минимум это работает так, что можно к примур написать HTTP клиент в common коде и использовать его хоть на андроиде, хоть на нейтив. Условный JavaFX тоже написан с использованием платформозависимых библиотек, разница в том что предоставляемый им API это некое подмножество-пересечение возможностей платформ, а на KMP использование родных возможностей платформ это фича.
                    Насчет имплементации интерфейсов, мне кажется это больше вопрос развития языка. Уже довольно давно идет обсуждение KEEP-87 про тайп классы. Не могу утверждать, что они когда-нибудь это обязательно реализуют, но внимание со стороны JetBrains к этому вопросу точно есть. Как и со стороны сообщества.
                      0

                      А откуда тогда берется необходимость юзать не common пакет, а самому выбирать с суффиксом -jvm, -native, -js.
                      Это разве не должно быть в рамках одного пакета условной компиляцией решаться?


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

                        +1
                        А откуда тогда берется необходимость юзать не common пакет, а самому выбирать с суффиксом -jvm, -native, -js

                        В Kotlin Multiplatform автору библиотеки всё равно нужно распространять артефакты, предназначенные для конкретных платформ — именно они содержат скомпилированные реализации и используются в рантайме и при компиляции/линковке соответствующего платформенного кода на стороне потребителя. Модули с суффиксами платформ (как ktor-client-jvm) как раз содержат эти платформенные части.


                        Но для библиотек уже давно можно указывать зависимость не на отдельные платформенные части — это пережитки прошлого, которые для некоторых библиотек ещё сохранялись — а одну зависимость на всю библиотеку в целом, после чего билд-система под капотом разберется, для какой платформы какие артефакты использовать. В недавнем пре-релизе 1.4-M2 проделали ещё немного работы, и зависимости на модули Ktor и kotlinx-библиотек тоже можно будет указывать как одну на всю библиотеку: https://blog.jetbrains.com/kotlin/2020/06/kotlin-1-4-m2-released/#hierarchical-project-structure


                        Это разве не должно быть в рамках одного пакета условной компиляцией решаться?

                        Мультиплатформенная библиотека может иметь среди таргетов, к примеру, Windows и macOS, и собрать их для публикации на одной машине возможности нет. Поэтому платформенные части разложения в разные модули, которые можно опубликовать отдельно с подходящих машин. И по-хорошему зависимости на эти платформенные модули пользователь всё равно не должен добавлять руками.

                    +1
                    Сильное заявление...

                    Тут скорее опыт тех команды, с которыми я работал.
                    Конечно, при желании можно и на Котлине писать отвратительный код. Один мой коллега был замечен в чрезмерном использовании `Any` вместо нормальных типов. За это был посрамлен и научен жизни.
                      +3

                      Если это ответ мне, то дело не в отвратительности кода. Просто nullable types и DDD – ну вообще перпендикулярны друг другу. "Стимулирует писать более чистый код" – ок, но DDD-то тут при чем?

                        +1
                        Как он жил вообще с Any? кастовал везде или что?
                          0

                          Да, как-то так :)

                        –2

                        Все эти виртуальные машины как-то слишком из нулевых. Пора переходить на native code. Чем плох тот же C++ или хотя бы Go?

                          +1

                          Есть проект Kotlin Native, который еще не успел развиться до уровня Go, но уже многое может

                            0
                            У виртуальных машин вырисовываются определенные преимущества по сравнению с нативным кодом.
                            1. динамическая оптимизация кода. В рантайме код докомпилируется под конкретные условия работы. Поэтому по производительности код jvm вполне сравним с c/c++.
                            2. VM обеспечивают мультиплатформенность. Одна программа на JVM одинаково работает как в Windows, так и в Linux и Mac.
                            3. В новой версии JVM — GraalVM обеспечивается интеоперабельность с Python и JS из коробки. В Native это делается заметно сложнее.
                              0

                              GraalVM — не новая версия JVM, а проект сбоку от основной JVM

                                +2

                                На практике производительность JVM обеспечивается закупкой пары дополнительных серверов, которые дешевле, чем программисты. Но долго ли ещё смогут наращивать производительность железа и снижать цену?

                                  –1

                                  Для этого и придумали микросервисы

                                +1
                                Тем что в место описания бизнес логики будешь разбираться с низкоуровневыми конструкциями, вылавливать всякие дескрипторы, отслеживать утечку памяти итд. При том что сама бизнес логика например не самого крупного производственного предприятия настолько сложна что описать ее на платформе с высоким уровнем абстракции, с готовым DDD типа 1С проблематично, не говоря уже о языках общего назначения.
                                  +1

                                  Вы про C++11 что-нибудь слышали? А Go тот вообще со сборщиком мусора. В Java так-то от памяти и потоков тоже на 100% не абстрагировались, насколько я слышал

                                    0
                                    Откройте например регламентные документы по части ведения кадрового учёта и расчёт заработной платы, сколько уйдет месяцев что бы просто в них разобраться, а сколько потребуется лет если не десятилетий что бы реализовать это все на C++ 11…
                                    А теперь представьте что эти регламенты еще к тому же меняются каждый месяц :)
                                    Ну или вон кейс Dodo Pizza посмотрите, на плюсах это все реализовывать наверно было бы не разумно даже на одиннадцатых
                                +3

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


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

                                  0
                                  Не уверен, что полностью правильно понял вашу позицию.
                                  Мой камень в огород PHP, Python, JS был лишь в плане строгой типизации.
                                    +1
                                    Ну не только по типизации прошлись, но и в целом по применимости языков.
                                    В PHP тоже есть null safety:
                                    class Foo
                                    {
                                        private DateTime $createdAt;
                                        
                                        public function __construct(DateTime $createdAt) 
                                        {
                                            $this->createdAt = $createdAt;
                                        }
                                    }
                                    
                                    class Bar
                                    {
                                        private ?DateTime $createdAt = null;
                                        
                                        public function __construct(?DateTime $createdAt) 
                                        {
                                            $this->createdAt = $createdAt;
                                        }
                                    }
                                    
                                    // NOT NULLABLE
                                    new Foo(new DateTime()); // object with datetime
                                    
                                    try {
                                        new Foo(null);
                                    } catch(TypeError $e) {
                                        var_dump($e->getMessage()); // TypeError 
                                    }
                                    
                                    // NULLABLE
                                    new Bar(new DateTime()); // object with datetime
                                    new Bar(null); // object with null
                                    


                                    И как понимаете — тоже на уровне IDE все ловится :) То есть некоторые аргументы ваши не имеют веса, либо не достаточно раскрыты. Крч, претензия — залезли на холиварную территорию, причем не совсем обоснованно.

                                    А так, Котлин — приятный язык, тут соглашусь. Правда пока не совсем понятно, как работать с бекендом без опыта в Java :( Куда не сунься, все или Андроидное или Спринговое, а тк опыта со всем этим хозяйством нет, то погружение в бекенд без Java кажется тем еще удовольствием.

                                    PS: не сочтите хейтерством, мои комментарии больше ориентированы на читателей, нежели на ваш труд.
                                      0
                                      Честно говоря, когда работал на PHP, ни про какие Null-safety слышно не было. Сейчас тоже попробовал поискать, но с ходу ничего не нашел кроме оператора `??`. Вероятно, это одна из новых фич и это похвально, что PHP дожил до такого уровня. Но, при том, что PHP остается очень востребованным языком, приходится констатировать, что свою долю рынка в последние 10 лет он методично теряет. Тем не менее, не хочу устраивать холивар по этому поводу, знаю много людей и компаний, которые до сих пор процветают на рынке PHP-разработки.

                                      Правда пока не совсем понятно, как работать с бекендом без опыта в Java

                                      Стоит разделять сам язык и экосистему. В язык войти новичку никаких сложностей нет. Понятно, что для высокого уровня требуется набить руку, но это везде так. Что касается экосистемы, то я не вижу как использование какой-то явовской библиотеки может потребовать знания, собственно, языка/синтаксиса Явы.
                                      Взять тот же JUnit/JUnit5. Весь явизм в Котлин сокрыт от разработчика.

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

                                      Я не против конструктивной дискуссии. Уже узнал для себя кое-что интересное и это прекрасно.

                                        +1
                                        Вероятно, это одна из новых фич и это похвально, что PHP дожил до такого уровня.

                                        Тайп хинты, позволяющие или нет null — фича php 5.0 (2004ый год).


                                        А null coalesce, про который вы говорите — это всего лишь сокращение if-оператора или тернарника:


                                        Заголовок спойлера
                                        // === PHP 4.0+ ===
                                        
                                        public function getDateOrNew()
                                        {
                                            if ($this->date === null) {
                                                $this->date = new DateTime();
                                            }
                                        
                                            return $this->date;
                                        }
                                        
                                        // === PHP 7.0+ ===
                                        
                                        public function getDateOrNew(): DateTimeInterface
                                        {
                                            return $this->date ?? $this->date = new DateTime();
                                        }
                                        
                                        // === PHP 7.4+ ===
                                        
                                        public function getDateOrNew(): DateTimeInterface
                                        {
                                            return $this->date ??= new DateTime();
                                        }

                                        В современном мире PHP — это такой же язык как Java или C# (по идее и подходам). В нём на порядки больше возможностей метапрограммирования, но чуть меньше возможностей по контролю типов (нет дженериков и типизации переменных, в остальном всё идентичное).

                                          +1
                                          Тайп хинты, позволяющие или нет null — фича php 5.0 (2004ый год).

                                          В тайп хинтах ничего нового нет. Они сейчас есть и в Питоне и Яваскриптах. Только на практике мало кто их использует. Проверка на null в один оператор тоже древнее изобретение.
                                          Под нал-сейфти сейчас понимается именно защит на уровне компилятора от присвоения нала значению, которое не предназначено принимать нал:
                                          val hereWillBeError: String = null // вот такое не должно пропускаться.
                                          val hereIsOk: String? = null // так нормально
                                          
                                            0
                                            Под нал-сейфти сейчас понимается именно защит на уровне компилятора от присвоения нала значению, которое не предназначено принимать нал:

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


                                            Если же требуется пример защиты при присвоении, то с полями можно так:


                                            class Example {
                                                public string $hereWillBeError = null; // ошибка
                                                public ?string $hereIsOk = null; // ок
                                            }
                                              0
                                              да, язык не компилируемый, понятно что не будет ошибок компиляции, тк ее просто нет… но тесты и простой запуск свалят все — явно и громко, если в not nullable присвоить null, и IDE будет ругаться… все как вы в статье писали
                                              sandbox.onlinephpfunctions.com/code/50feba42363f7a187020c7ac99eb72478929def7

                                              а еще и компайл в неком виде есть в некоторых фреймворках — например сборка DI контейнера не пройдет или очистка кеша

                                              а вот в Питоне они не понятно зачем, я когда решил поиграться с Пайтоном. ` выставил тайпхинт, а он игнорил меня :):) там оказывается это не работает, а только для каких-то парсеров сделано

                                  • UFO just landed and posted this here
                                      –1
                                      Дело в том, что второй вариант является антипаттерном, поэтому в боевом коде он встречается редко. И, если уж сравнивать с Котлином, то в объявлении:
                                      class X {
                                          var a: String = ""
                                      }
                                      

                                      На самом деле уже заложен и сеттер, и геттер. Этот код абсолютно аналогичен следующему:

                                      class X {
                                          var a: String = ""
                                              get() = field
                                              set(value: String) {
                                                  field = value
                                              }
                                      }
                                      

                                      И даже в этом виде он более компактен, чем в Яве, хотя функционально является полным аналогом того, что у вас в первом варианте приведен.
                                      • UFO just landed and posted this here
                                          –1
                                          Я не думаю, что существуют целенаправленные исследования, доказывающие что один язык объективно лучше другого. Скорее все останавливается на утверждениях, что у такого-то языка такая-то ниша. Это я про личный опыт. Безусловно, личный.

                                          А паттерны появились не на ровном месте.
                                          • UFO just landed and posted this here
                                            +3
                                            Никто не пишет
                                            public int x;
                                            потому что есть спека java beans (и библиотеки, поддерживающих эту спеку, тупо не будут работать с полем), а также куча других случаев, когда работа напрямую через поле неприемлемо.
                                            Внутри класса всё-таки почти никто через геттеры-сеттеры не работают (да и то, бывают ситуации, когда это оправдано).
                                            Так что про «программисты думать не хотят» — это глупость. Такой подход годится для write-once кода. Сегодня норм и прямой доступ по полю, через неделю, когда понадобится подключить загрузку объекта из конфига, придётся писать геттеры-сеттеры. А еще через неделю надо будет завраппить класс и всё — приплыли: прямой доступ к любым полям этого класса становится вообще недопустимым. А еще поле нельзя преобразовать в лямбда-функцию, в отличие от геттера.

                                            А чтобы не писать boilerplate, давным давно существует Lombok, но, как оказалось, подружить в одном проекте Lombok с Kotlin-кодом весьма нетривиально (точнее, через maven сборка настраивается без проблем, но Eclipse с таким хитрым конфигом не очень дружит).
                                              +1

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

                                                0
                                                Ну вообще-то проблемы были исключительно от того, что я запихнул в одном проекте смешал код на java и kotlin. Всё-таки, более типичный случай когда их разделяют по jar-кам и таких проблем не возникает.
                                                А от использование Lombok в чистом java проекте проблем не наблюдал, да и поддержка со стороны IDE нормальная. А вот поддержка Kotlin-а со стороны Eclipse после java мне показалась слабоватой, конкретных причин не назову, это было года 3 назад. Может уже получше стало, хотя мне кажется, что авторам языка не особо интересно развивать его поддержку в конкурирующем продукте.
                                              • UFO just landed and posted this here
                                                  +1
                                                  Я тоже могу привести пример нескольких библиотек, которые умеют и с полями работать. Но если работа с бинами — вспомогательный функционал библиотеки, то просто берут стандартный java.beans.Introspector, получают набор геттеров-сеттеров и работают через них.

                                                  Если говорить про EE, то, например, через CDI просто не будут работать классы с полями вместо геттеров/сеттеров (если только не использовать Singleton scope), т.к. при обращении с injected-бином по сути идёт работа со сгенерированным proxy-классом, тут построить работу с полями в принципе не возможно. Про врапперы я выше уже писал, их тоже не сделаешь нормально.

                                                  В целом, если вы пишите код, который будет использоваться в других проектах как библиотека, прямое использование public не-final полей, с которыми требуется взаимодействовать снаружи библиотеки — моветон, т.к. часть паттернов просто несовместима с использованием полей.
                                                  Если же говорить про код внутри проекта — рано или поздно где-то придётся заменять поля на геттеры-сеттеры. Только вот попутно это приведёт к необходимости модификации кучи мест, где уже было сделано обращение к полям.

                                              +2

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

                                                –1
                                                Проблема в том, что мы заранее не знаем где выстрелит этот оставшийся 1 процент.
                                                  +2
                                                  Вы страхуетесь не от того, геттеры и сеттеры семантически ничего не делают относительно public, то есть инкапсуляцию теряете так и так, а равно — плодите высоко-связанный код

                                                  DDD упомянули, но геттеры и сеттеры все же обсуждаются как «вариант» написания кода :)

                                                  В Котлине data-классы названы как data не просто так. А вот использовать data object кроме как DTO — вопрос уже к программистам, пишущий код и строящим архитектуру.
                                                    0

                                                    data class – это не обязательно DTO. Value objects из DDD, да даже просто иммутабельные модели – это все прекрасно реализуется с помощью data class.

                                                      +1
                                                      Да, но сразу есть одно НО:

                                                      • в дата-классах Котлина есть свойства, через неявные магические сеттеры/геттеры
                                                      • мое понимание ООП (если ограничиться этой парадигмой при обсуждении) видит в этом риск использования этих свойств, знаний и «бесплатного» доступа к этому состоянию/интерфейсу плодить связанный код, который завязан на состоянии тех или иных объектов и который мог бы быть помещен в эти самые VO и иммутабельные сущности


                                                      Вы уж извините, я не джавист/котлинист/шарпист, но точно знаю о таких проблемах как минимум в Java, именно война против анемичных моделей идет из языков Java/C#
                                                      и абсолютно точно знаю о таких проблемах в больших PHP-проектах и даже имею с ними дело ежедневно

                                                      PS: ВЫше отметил, что Котлин крутой. Иммутабельность по дефолту, дата-классы, сахар с лямбдами, добавление методов к классами из др модулей — заставляют слюни пускать, но как и отметил выше — для бекендера без знаний Java (на достойном уровне) тяжеловато на текущий момент браться за Котлин, тк своего родного маловато в нем — могу ошибаться.
                                                      И в этом плане Golang для целого ряда программистов из Ruby, PHP, JS кажется отличным вариантом
                                                        0
                                                        в дата-классах Котлина есть свойства, через неявные магические сеттеры/геттеры

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


                                                        мое понимание ООП (если ограничиться этой парадигмой при обсуждении) видит в этом риск использования этих свойств, знаний и «бесплатного» доступа к этому состоянию/интерфейсу плодить связанный код, который завязан на состоянии тех или иных объектов и который мог бы быть помещен в эти самые VO и иммутабельные сущности

                                                        Во-первых, не обязательно ограничиваться ООП, парадигма ФП неплохо реализуется с помощью Котлина.


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


                                                        для бекендера без знаний Java (на достойном уровне) тяжеловато на текущий момент браться за Котлин — могу ошибаться

                                                        Тут да, полностью согласен. Пока что так. Даже в андроид разработке, где Котлин уже стал "официально рекомендуемым" языком, лучше все-таки знать Java. Вернее даже "знать JVM", многие вещи в учебниках по Котлину просто не описаны, потому что "там все, как в Java".

                                                          0
                                                          Во-первых, не обязательно ограничиваться ООП
                                                          Ну я не просто так сделал оговорку (не для того, чтобы за нее меня же и мокали) :) Таки да, вы правы
                                                          Процедурный подход тоже становится приятным с дата-классами
                                                            0
                                                            да уж, я вот в такой ситуации оказался: поигрался с Котлином пару выходных, облизался. А что-то серьезное замутить: интероп с Java, там и спринг и хайбернейт и джексоны/мэксоны… JVM финты для интеропа и вот это все

                                                            мне, как нулевому (абсолютли) джависту это показалось сомнительным «плюсом» «нового» языка, который имеет крутые фичи
                                                              +2

                                                              Ну все-таки справедливости ради проблема наличия фреймворка – это не совсем вина (молодого) языка. Не было бы интеропа с джавой, не было бы и того, что сейчас имеем.


                                                              А так, вместо Spring – ktor, вместо Jackson – kotlinx.serialization. Со временем и остальное подтянется. Но пока что, да, нужен опыт Java.


                                                              Вообще же, для меня одни из самых крутых фич котлина – это не только null safety и синтаксический сахар, а structured concurrency, контракты, компиляция в native, быстрое развитие языка по сравнению с джавой.


                                                              Плюс, я сейчас в основном мобильщик, а не бэкендер, а на Андроиде выбирать между Java 8 и Kotlin – ну тут вообще без вариантов.

                                                            0

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

                                                      0
                                                      Этот код может генерироваться инструментом. Один пример такого инструмента я уже приводил, но на самом деле их намного больше.
                                                      0
                                                      Дело в том, что второй вариант является антипаттерном

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


                                                      Или вы имеете ввиду, что когда вы сделали параметр, вы еще не знаете будет ли доступ к нему сохранять инвариант или нет? Мол сразу сделаем методы для установки, вдруг потом придется вместе с ним еще что-то менять? Ну тогда — это просто странно смотрится… вначале мы задумали одно, а потом вдруг сделаем совершенно другое.

                                                      0
                                                      @JvmField
                                                      var x = 0

                                                      и куда-то пропадают сеттеры и геттеры)
                                                        +1
                                                        >вместо того, чтобы писать просто:
                                                        >public int x;

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

                                                        >Это программисты думать не хотят.
                                                        Думать за Hibernate? Ну, в каком-то смысле правильно не хотят. Зачем еще раз думать над тем, над чем уже подумали?
                                                          +1

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

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

                                                            А даже если проблем и не возникает — уж как минимум такие инструменты затрудняют иногда понимание поведения системы в целом. Уже на уровне ломбок это вполне заметно.
                                                        –1

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


                                                        data class StorableObject(
                                                            var id: String? = null,
                                                            var data: String? = null
                                                        ) {
                                                            // Место размещения мапера зависит от задачи
                                                            constructor(wm: WorkModel): this(
                                                                id = wm.id.takeIf { it != -1 }?.toString(),
                                                                data = wm.data.takeIf { it.isNotBlank() }
                                                            )
                                                        
                                                            // Место размещения мапера зависит от задачи
                                                            fun toWorkModel(): WorkModel = WorkModel(
                                                                id = id?.toInt() ?: -1,
                                                                data = data ?: ""
                                                            )
                                                        }

                                                        легко пишется на Джава в том же самом подходе.


                                                        @Data
                                                        public class StorageObject {
                                                            private String id;
                                                            private String data;
                                                        
                                                            public StorageObject(@NonNull WorkModel workModel) {
                                                                id = Optional.ofNullable(workModel.id).filter(value -> value != -1).map(String::valueOf).orElse(null);
                                                                data = Optional.ofNullable(workModel.data).filter(not(String::isBlank)).orElse(null);
                                                            }
                                                        
                                                            public WorkModel toWorkModel() {
                                                                return new WorkModel(
                                                                        Optional.ofNullable(id).map(Integer::valueOf).orElse(-1),
                                                                        Optional.ofNullable(data).orElse("")
                                                                );
                                                            }
                                                        }

                                                        Да, чуть больше символов, но это как по мне вообще мелочь. Тк именно подход как делать один и тот же.


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

                                                          +2
                                                          Не просто символов больше, а читаемость хуже
                                                          id? против Optional.ofNullable(id)
                                                          toInt() против map(Integer::valueOf)
                                                          it.isNotBlank() против not(String::isBlank)
                                                          Если вам платят за количество кода, то java здесь выигрывает, да)
                                                            0

                                                            Вы действительно думаете, что это настолько существенное различие что вы напишите этот код в два раза быстрее и он еще работать будет быстрее?
                                                            Когда вы пишите на языке постоянно то вы вообще не обращаете внимание там id?или Optional.ofNullable(id).


                                                            Так же на мой вкус вот такой код id?.toInt() ?: -1 больше смахивает на брейнфак в то время как Джаовский делает тоже самое и также в одну строку, но читая его все просто и понятно Optional.ofNullable(id).map(Integer::valueOf).orElse(-1)


                                                            И даже два наших мнения показывают что ваши утверждения субъективные.


                                                            П.С. и вообще в java я возьму mapstruct и не буду писать весь этот код :)))) В этом и сила java, что всегда можно сделать разными путями.

                                                              +1
                                                              Причем тут быстрота, тут дело в читаемости, и имхо в kotlin это реализовано лучше. У kotlin тоже есть свои плюшки (включая большинство из джавы): dsl, корутины, мультиплатформенность кода и тд. Конечно, все зависит от программиста, и там, и там можно как запороть, так и искусно написать код
                                                                +2
                                                                и имхо в kotlin это реализовано лучше.

                                                                в том то и дело что ИМХО. Но я изначально говорил что суть написание кода остается такой же как и в Джаве. Те это не какой то сдвиг парадигмы как в Расте. А просто сахарка присыпали причем много можно делать на джаве сторонними библиотека или вообще вкусовщина.


                                                                корутины,

                                                                Я живу в радость с реактивными библиотеками как Lettuce, Vert.x, AWS SDK v2 и тд
                                                                где все либо с коробки Mono/Flux либо оборачивается легко. И зачем они мне?
                                                                А взять какой нибудь Хибернейт, то его не прикрутишь к корутинам и не сделаешь в один миг асинхронным и не блокирующим.


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

                                                                у нас есть Graal или Vertx


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


                                                                П.С. А если вы сходите в Го группы то вам расскажут, что https://github.com/bxcodec/go-clean-arch/blob/master/article/usecase/article_ucase.go#L33-L82 это нормально для Го,
                                                                а вот такое на Джаве


                                                                public Flux<Article> fillAuthor(@NonNull List<Article> articles) {
                                                                    return Flux.fromIterable(articles)
                                                                            .flatMap(article -> repository.getById(article.author.id)
                                                                                    .map(author -> {
                                                                                        article.author = author;
                                                                                        return article;
                                                                                    })
                                                                            );
                                                                }

                                                                это куча библиотек и не Го стиль :)))


                                                                Но при этом Го тоже должен подвинуть Джаву :))))

                                                                +1
                                                                > Так же на мой вкус вот такой код id?.toInt() ?: -1 больше смахивает на брейнфак в то время как Джаовский делает тоже самое и также в одну строку, но читая его все просто и понятно Optional.ofNullable(id).map(Integer::valueOf).orElse(-1)

                                                                Ну это же чистая вкусовщина. На мой взгляд оба варианта вполне норм читабельны и понятны. Да, на kotlin я начал посматривать где-то несколько дней назад, но конструкции вида «id?» или оператор имени Элвиса интуитивно понятны и используются много где.
                                                            0
                                                            Я не очень интересуюсь этой темой, знаю лишь в общих чертах, что такое Java. Насколько я знаю, Kotlin работает поверх JVM. В свою очередь чьей собственностью является JVM и не будет ли в определённый момент вопрос переведён в юридическую плоскость? Java — коммерческий продукт. Не сможет ли он ограничить использование виртуальной машины при возникновении конкуренции со стороны JetBrains, тем самым осложнив им жизнь?
                                                              0
                                                              Не сможет ли он ограничить использование виртуальной машины при возникновении конкуренции

                                                              en.wikipedia.org/wiki/HotSpot
                                                                0

                                                                На сегодня JVM от Оракл — это лишь одна из реализаций. И даже ее есть две версии: проприеритарная и OpenJDK с версией GPL.
                                                                При том, что Оракл отменил поддержку Java 8, она реально доступна от других поставщиков.

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

                                                                  По моему опыту, утверждение о том, что без знания Java поход в в Kotlin невозможен, безосновательно.
                                                                  Проблема Котлина без Ява специфична. Например, чисто котлинисты не знают устройство структур: HashMap, LinkedList, etc. Просто потому, что в Котлине идет Map и MutableMap, которые внутри — LinkedHashMap. Ни разу не видел, чтоб это как-то влияло на качество кода.
                                                                  Так же котлинисты хуже знают внутренее устройство, примитивы и шаблоны многопоточности. Просто потому, что в Котлине работа с многопоточностью реализована на более высоком уровне.
                                                                  Я не знаю людей, которые бы с радостью переходили с Котлина на Яву, но и такие прецеденты у меня были. Это требует плотного штудирования литературы и освоения низкоуровневых вещей. Но это возможно. Занимает пару месяцев.

                                                                    +1
                                                                    Скажу больше, и многие джависты «хуже знают внутренее устройство, примитивы и шаблоны многопоточности»:-).
                                                                    Вы путаете ситуацию «хуже знают» с вообще " без знания Java".
                                                                    Скажем, у меня в BG С++. И я сразу хочу учить Kotlin. В результате, очень быстро все выражается в необходимость изучения Java библиотек и фреймворков и тонких особенностей их использования в Kotlin. При том что в обоих мирах постоянно происходят изменения и следить приходиться за обоими, чтобы быть на уровне. Это дополнительная нагрузка на программиста.
                                                                      +2
                                                                      Я все-таки не понимаю почему API некой библиотеки требует знания Java.
                                                                      У меня был джун, которого взяли из мира Шарпа и он не знал Яву до этого. Парень толковый и ничем не выдавал своего незнания классической Явы. В Котлин зашел быстро и каким-то невежеством не отличался.
                                                                      В качестве кандидатом мы всегда рассматривали выходцев из всех ООП языков.
                                                                    0
                                                                    С Java знаком весьма поверхностно (проходил давно курс и с тех пор не практиковал) и ради интереса изучал Kotlin. В целом язык показался интересным, но при попытке начать работать с реальным проектом оказалось, что ушки Java торчат отовсюду и без понимания никуда…
                                                                    Очень жаль. И даже везде в обучающих материалах (курсы, книги) проводят сравнение этих языков в стиле на Java делали так, а на Kotlin иначе. Предполагая, что изучающие должны знать Java. Поэтому у меня сложилось впечатление, что создатели языка даже не предлагают изучать его отдельно от Java (без знания Java).
                                                                      0
                                                                      Ну, ушки — это не так страшно и не так интересно. Сейчас у любого языка есть какие-то ушки — время изобретений с нуля прошло.
                                                                      Мне больше интересно:
                                                                      И даже везде в обучающих материалах (курсы, книги) проводят сравнение этих языков в стиле на Java делали так, а на Kotlin иначе.

                                                                      Вам это помогало или мешало?
                                                                      Мне этот вопрос интересен — готовлю курс по Котлину. Буду благодарен, если ответите развернуто.
                                                                        0
                                                                        > готовлю курс по Котлину.

                                                                        На jetbrains academy есть вроде неплохой курс, может пригодится.
                                                                          0
                                                                          Хотелось бы курс по чистому Контлину, без Явы (или не очень много, для тех кто не знает или как я уже забыл=)). И не только по основам, но и по окружению (библиотекам, фреймворкам). По Котлину в основном о разработке под Андроид курсы, а вот по Спрингу не видел. И хотелось бы не только основы синтаксиса, но и углубленные вещи (многопоточность и прочее). Т.е. Котлин за пределами Андроида, а то много статей на тему как мы используем Котлин-«крутой проект», но обучающая информация только по Котлин-Андроид. Я думаю есть много желающих изучить язык и использовать, но вся информация по тому же спрингу только на Ява…
                                                                      –1
                                                                      После котлина пыха с её долларами кажется даже вполне ничего. Тяжело представить, что кто-то реально вникает в десятки тысяч строк подобного кода. Очень на любителя ИМХО
                                                                        +4
                                                                        Поэтому тот факт, что на Kotlin проект получается раза в 2-3 компактнее, более легкочитаемый, более надежный в плане защиты от NullPointerException

                                                                        Вы щас серьезно? А можно поинтересоваться — в проектах на Котлине с каким объемом кода вы участвовали?
                                                                        Потому что я заходил на проект, которому на тот момент было более года, десяток микросервисов, всё на Котлине — ииииии!
                                                                        — Дурацкий val/var где можно и нельзя. Какого типа эта переменная? Какие классы туда могут попадать?
                                                                        — Код нечитабелен. Абсолютно. Куча лапши из .apply/.run/.also с сменой нескольких контекстов.
                                                                        — Объектная ориентация нарушена. Ну зачем нам субклассирование. Мы напишем экстеншн метод и скопипастим его в пару-тройку модулей. Потому что быстренько.
                                                                        — От NPX при работе с Java-библиотеками не спастись.
                                                                        — Data class-ы ничем не лучше ломбокнутых джавовских.
                                                                        — Корутины настолько эзотеричны и зубодробительны в понимании, что ими никто не пользуется. Привет старый добрый Executor, Runnable, Future, concurrency.

                                                                        То есть Котлин не решает проблемы. Он провоцирует их создавать. На крупном проекте через год-два у вас будет всё засрано копипастом и лапшой, а разборки с техническим долгом будут занимать 80-90 процентов времени лидов/архитектов.

                                                                        Резюмирую: пока язык не будет понятен тупо при открытии кода в блокноте, а не в IDE, пока он не будет защищать программиста от использования антипаттернов и копипаста — это плохой и сырой язык, пользоваться им невозможно.
                                                                          +2
                                                                          А можно поинтересоваться — в проектах на Котлине с каким объемом кода вы участвовали?

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

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

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

                                                                          Но после освоения языка, те же var и val покажутся действительно очень логичным и мощным инструментом.
                                                                            0
                                                                            Плохой код можно написать на любом языке

                                                                            Джава от этого как минимум защищает. Строгость, обязательность в выполнении объектной ориентации и следования объявлениям. Котлин же, такое ощущение, что был сделан чтобы «херак — и в продакшн».

                                                                            нужно еще разрабатывать качественную архитектуру и соблюдать определенную культуру разработки.

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

                                                                            те же var и val покажутся действительно очень логичным и мощным инструментом

                                                                            Я не вижу здесь инструмента. Я вижу экономию на тексте в духе «Внни т прнс?».
                                                                            final ClassName varName = ... 

                                                                            на мой взгляд прозрачнее и лучше чем
                                                                            val varName = ... 

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

                                                                              Не защищает

                                                                                +2
                                                                                Я не вижу здесь инструмента. Я вижу экономию на тексте

                                                                                Если это так сильно мешает жить, то что мешает на уровне соглашения в команде обязать полную форму писать:


                                                                                val varName: ClassName = ...

                                                                                Так-то var для type inference и в Java есть.


                                                                                Потому что их пишут не по контексту принадлежности, а бизнесовому.

                                                                                И в этом как раз и может быть польза. Но опять же – не нравится, не используйте, язык дает такую возможность, но не навязывает ее. Зато можно делать мощные штуки типа контекстно-зависимых расширений с автодополнением и проверкой компилятором.


                                                                                Куча лапши из .apply/.run/.also с сменой нескольких контекстов.

                                                                                Да, это может стать проблемой. Но опять же – не надо лепить куда попало. Если на код ревью я вижу такую мешанину, и мне непонятно, что происходит, я прошу переписать и избавиться от apply/run/also.

                                                                                  0
                                                                                  Так-то var для type inference и в Java есть.

                                                                                  Есть. Но «котлин-стайл» — это использовать var/val.

                                                                                  … И в этом как раз и может быть польза. Но опять же – не нравится, не используйте…
                                                                                  … Да, это может стать проблемой. Но опять же – не надо лепить куда попало.

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

                                                                                    val varName: ClassName = ... не противоречит котлин-стайлу, насколько я помню. Что котлин, что джава дают одни и те же варианты:


                                                                                    val x = "Test"
                                                                                    val x: String = "Test"

                                                                                    final var x = "Test"
                                                                                    final String x = "Test"

                                                                                    В чем разница-то?


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

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


                                                                                    val x = SomeClass().apply {
                                                                                        doSomething1()
                                                                                        doSomething2()
                                                                                        doSomething3()
                                                                                    }

                                                                                    чем так:


                                                                                    val x = SomeClass()
                                                                                    x.doSomething1()
                                                                                    x.doSomething2()
                                                                                    x.doSomething3()

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

                                                                                      0
                                                                                      В чем разница-то?

                                                                                      Для строк — ни в чем. Когда у вас с правой стороны стоит фабричный метод, который порождает что-то более сложное — хорошо бы с левой иметь не безликий val, а объявление типа. Код должен быть ясным.

                                                                                      val x = SomeClass().apply {
                                                                                          doSomething1()
                                                                                          doSomething2()
                                                                                          doSomething3()
                                                                                      }


                                                                                      Если вам так нравится чейнить вызовы — давайте уж писать сам класс с поддержкой builder pattern:
                                                                                      val x: SomeClass = SomeClass()
                                                                                        .doSomething1()
                                                                                        .doSomething2()
                                                                                        .doSomething3();
                                                                                      


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

                                                                                      Продолжая аналогию: пистолет из которого хорошо забиваются гвозди, но нельзя застрелиться — лучше, чем пистолет из которого можно только застрелиться.
                                                                                      Если вы не киллер, конечно, ЕВПОЧЯ.
                                                                                        +1
                                                                                        хорошо бы с левой иметь не безликий val, а объявление типа. Код должен быть ясным.

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


                                                                                        давайте уж писать сам класс с поддержкой builder pattern

                                                                                        Если вы сами пишете этот класс – не проблема. А если это библиотечный класс?


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

                                                                                        Не совсем верное продолжение. "Чем пистолет, из которого можно только застрелиться" – да, лучше. Но где вы видели пистолет, который откажется выстреливать гвоздь, если вы его поднесли к виску и нажали на спусковой крючок?

                                                                                  +3
                                                                                  Я вот не совсем понимаю, в чем проблема с extension-методами. Это же всего-лишь код, который работает с публичным интерфейсом класса. Семантически аналогично какому-нибудь StringUtil, который есть в каждом втором проекте на Java. Или доброй части кода из Guava, ApacheCommons, да даже в JDK есть Collections, Files, Paths и т.п.
                                                                                  На мой взгляд эта фича только способствует ООП, потому-что позволяет четко разделять основную логику интерфейса от методов, которые объявлены просто чтобы с ним было удобно работать. Ну, или если код на Java таким не страдает или не имеет доступ к изменению интерфейса, то позволяет программисту не искать обертку, в которую надо завернуть целевой класс, чтобы получить желаемый функционал и не писать его в нескольких местах. Что, в общем, в обоих случаях win-win. Работаю с интерфейсом, переиспользую код, не ввожу новые абстракции.
                                                                                    +2

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

                                                                                      0
                                                                                      Так в том то и дело, что код пишется для людей, и на Котлине он пишется нечитабельно.
                                                                                      Я уже который коммент об этом талдычу.

                                                                                      если вам непонятно что находится в переменной без указания типа, то это — сигнал к рефакторингу

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

                                                                                        Если у вас фабрика возвращает интерфейс, то вы этот интерфейс и получите, хоть с явным указанием типа, хоть без.

                                                                                          0

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


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


                                                                                          Касаемо val/var. Еще раз: человек — не компилятор. Если вам необходимы типы локальных переменных, то лучше подумать над следующими вопросами:


                                                                                          1. Зачем мне это? Не пытаюсь ли я делать ту работу, которую должен делать компилятор или статический анализатор?
                                                                                            Например, для редактирования кода человек использует IDE. Блокнот/web используется для его чтения.
                                                                                          2. Достаточно ли мои методы просты? Может, тут надо не типы указывать, а часть логики по приватным методам разбить? Также, привет всяким SOLID, YAGNI.
                                                                                          3. Корректные ли имена используются? Суть должны быть понятна из имен, а не типов.

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


                                                                                          Ровно по этим же аргументам лучше использовать static import. Там, где имена импортируемых элементов говорящие, конечно (isEmpty(...) импортируем, builer() — нет).

                                                                                            0
                                                                                            Например, для редактирования кода человек использует IDE. Блокнот/web используется для его чтения.

                                                                                            Да, для анализа pull-реквестов, например. Без типизации переменной понимать что хотел сказать автор кода — более затруднительно.

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

                                                                                            Когда мне нужен лев, а не утка — мне пофигу как кого зовут.

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

                                                                                            Чойта вдруг? Bean-методы тоже поди харамны? А конфиг с такими методами? А это уже фабрика.

                                                                                            static import удобнее сугубо тем, что он лаконичнее. Лишь бы схожих именований не было.
                                                                                              0
                                                                                              Да, для анализа pull-реквестов, например. Без типизации переменной понимать что хотел сказать автор кода — более затруднительно.

                                                                                              С моей т.з. это не так. Код с val/var (а они и в Lombok для Java есть) более лаконичный и reviewer тупо меньше читать должен. Становится меньше визуального мусора, поэтому и проще вычленить логику.

                                                                                              Когда мне нужен лев, а не утка — мне пофигу как кого зовут.

                                                                                              А можно конкретнее?

                                                                                              Чойта вдруг? Bean-методы тоже поди харамны? А конфиг с такими методами? А это уже фабрика.

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

                                                                                              Да, я сам N-ое кол-во лет назад говорил «зачем нужны лямбды в Java, есть же анонимные классы — сразу видны все типы, а пишутся они в IDE быстро».
                                                                                                0
                                                                                                А можно конкретнее?

                                                                                                Можно. Я не хочу помнить/сомневаться. Я хочу видеть. И я хочу чтобы в случае несовпадения левой-правой части была ошибка компиляции.
                                                                                                  +1
                                                                                                  А в лямбдах вы тоже типы параметров указываете?

                                                                                                  Под примерами я имел ввиду пример, что где помогает.
                                                                                                    –1
                                                                                                    а при чем тут лямбды? внутри тушек лямбд — естественно указываю, если это не однострочник
                                                                                    +1
                                                                                    Касаемо apply, also, let, with, run действительно интересно получается, вроде как полезно использовать и должно увеличить читаемость!!! но при объединении < 2-3 строк имхо бесполезны и только загромождают код лишнеми 2 строками из скобок, для 4+ помогают действительно
                                                                                      0
                                                                                      Не вкурил до сих пор разницу между ними, ясное дело либо this, либо it, но вот run vs apply или let vs also?)

                                                                                      public inline fun <T> T.apply(block: T.() -> Unit): T
                                                                                      public inline fun <T> T.also(block: (T) -> Unit): T
                                                                                      
                                                                                      public inline fun <T, R> T.run(block: T.() -> R): R
                                                                                      public inline fun <T, R> T.let(block: (T) -> R): R
                                                                                      
                                                                                      +4
                                                                                      Резюмирую: пока язык не будет понятен тупо при открытии кода в блокноте, а не в IDE, пока он не будет защищать программиста от использования антипаттернов и копипаста — это плохой и сырой язык, пользоваться им невозможно.

                                                                                      Т.е. любой существующий на сегодняшний день язык – плохой и сырой, пользоваться которым невозможно. "Есть два типа языков программирования — те, которые все ругают, и те, на которых никто не пишет".

                                                                                        –3
                                                                                        Т.е. любой существующий на сегодняшний день язык – плохой и сырой

                                                                                        Нет. Просто потому что далеко не во всех есть лапша со сменой контекстов.
                                                                                        А в Котлине есть. Java, C, C++, Delphi, Python, vanilla JS я спокойно пойму не скачивая проект с гитхаба.
                                                                                        Котлин непрозрачен.
                                                                                        +1
                                                                                        Куча лапши из .apply/.run/.also с сменой нескольких контекстов
                                                                                        А никто не говорит, что так нужно делать, смешивать контексты, делать кучу вложенностей из scope методов, более того, говорят так не делать.

                                                                                        Про экстеншн методы вообще не понял. Если что, то они не имеют доступа к приватным полям, это обычные статик методы. Лучше же конечно иметь StringUtil и ещё миллион Util классов? Нет спасибо, экстеншены одно из самых приятных вещей в Котлине.
                                                                                        — Корутины настолько эзотеричны и зубодробительны в понимании, что ими никто не пользуется. Привет старый добрый Executor, Runnable, Future, concurrency.

                                                                                        Этот абзац прям классическое: «Моя лошадь лучше этого вашего дурацкого автомобиля».
                                                                                        То, что ими никто не пользуется — наглая ложь. И не особо они сложные и, в отличии от «старых добрых ...», позволяют легко писать асинхронный код в синхронном стиле без кучи коллбеков.
                                                                                          –2
                                                                                          А никто не говорит, что так нужно делать, смешивать контексты, делать кучу вложенностей из scope методов, более того, говорят так не делать.

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

                                                                                          Лучше же конечно иметь StringUtil и ещё миллион Util классов? Нет спасибо, экстеншены одно из самых приятных вещей в Котлине.

                                                                                          Да, лучше util-классы. Они лежат отдельно, и синтаксически не нарушают объектную ориентацию. Отдельное «спасибо» за отсутствие static в котлине.

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

                                                                                          Судя по туториалам — сложные, эзотеричные, непонятные. Ну, а исходя из ситуации на проекте — почему-то вместо корутин требовалось использовать экзекуторы.
                                                                                            +1
                                                                                            Судя по туториалам — сложные, эзотеричные, непонятные.

                                                                                            Ну это оценочное суждение. Да, туториалы на сайте с документацией по котлину обычно описывают «как делать», но не описывают «а зачем делать так, если и на экзекьюторах норм».
                                                                                            Применимо к котлину идея structured concurrency описана у Елизарова в блоге. Смысл structured concurrency детально разобран тут.
                                                                                              0
                                                                                              но не описывают «а зачем делать так, если и на экзекьюторах норм»

                                                                                              Именно. На экзекьюторах + примитивы синхронизации, которые известны из классики многопоточного программирования + конкурентные коллекции. По уши.
                                                                                              «coroutines are lightweight threads».

                                                                                              Ок, зачем мне нити, которые легче чем обычные нити, но с которыми обращаться не как с обычными?
                                                                                            0
                                                                                            позволяют легко писать асинхронный код в синхронном стиле без кучи коллбеков

                                                                                            Что не для всех является плюсом. Нужно в голове держать две парадигмы для кода, который выглядит одинаково.
                                                                                          +1

                                                                                          Многие спорят о том, в чем секрет успеха Java. Да, язык консервативен, да, многословен, часто не безопасен, не слишком выразителен и неконсистентен.
                                                                                          Котлин в свою очередь довольно приятный язык, с очень чёткой маркетинговой нишей синтаксического сахара.
                                                                                          Но я думаю Java будет жить. Потому что писать плохой код можно на любом языке — я видел очень много плохого кода на Java и уверен, что Котлин даёт программисту свободу написать ещё хуже (в чем конечно нет вины языка). Java код скушный, но обычно понятный, ужасы кроются на уровень выше — в кривых абстракция, отсутствии архитектуры, копипасте и т.п. Но понятный код даёт ложное ощущение контроля и возможность средним программистам связать воедино куски, которые они не понимают.
                                                                                          Ни в коем случае не утверждаю, что все Java программисты средние — там немало ярких и интересных личностей. Но массовая популярность и спрос, а главное культура языка делают свое дело. И в копилку плюсов идёт все-же возможность как-то заставить этот хаос работать.
                                                                                          Kotlin на мой взгляд это возможность принести в Java проект немного свежего воздуха. Но если вы почувствовали вкус свободы — не стоит останавливаться, идите дальше — есть Scala, Haskell, Rust и много других интересных языков.
                                                                                          Развивайтесь.

                                                                                            +3

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

                                                                                              0

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

                                                                                                +1
                                                                                                Java-разрабы дешевле? Я посмотрел на HH — и не вижу, чтобы Java были дешевле Kotlin-only.
                                                                                            0
                                                                                            Kotlin замечательный язык. Для меня останавливающим фактором является текущая скорость развития JVM — на подходе records и virtual threads — и то будут ли другие языки успевать за этим. Java и JVM развиваются синхронно и в этом, как мне кажется, основное преимущество перед другими JVM-языками.
                                                                                              0
                                                                                              Я правильно понял, что виртуальные потоки — это аналог корутин?
                                                                                                0
                                                                                                Да.
                                                                                                Virtual threads are just threads, but creating and blocking them is cheap. They are managed by the Java runtime and, unlike the existing platform threads, are not one-to-one wrappers of OS threads, rather, they are implemented in userspace in the JDK.
                                                                                            • UFO just landed and posted this here
                                                                                                0
                                                                                                Спасибо за разъяснение. Нисколько не сомневаюсь в том, что Скала реально мощный язык и сыграл значительную роль в развитии рынка языков. Лично я сделал выбор после прочтения обзоров сравнения между Котлином и Скалой. Согласно этому обзору они очень близки, но все же Котлин несколько удобнее. Добило меня то, что попадались на глаза проекты, которые перешли со Скалы на Котлин (не помню какие).
                                                                                                • UFO just landed and posted this here

                                                                                              Only users with full accounts can post comments. Log in, please.