Эта статья рассказывает о языке программирования Kotlin. Вы узнаете о причинах появления проекта, возможностях языка и посмотрите несколько примеров. Статья написана в первую очередь в расчете на то, что читающий знаком с языком программирования java, однако, знающие другой язык, тоже смогут получить представление о предмете. Статья носит поверхностный характер и не затрагивает вопросы связанные с компиляцией в javascript. На официальном сайте проекта вы можете найти полную документацию, я же постараюсь рассказать о языке вкратце.

О проекте

Не так давно компания JetBrains , занимающаяся созданием сред разработки, анонсировала свой новый продукт - язык программирования Kotlin. На компанию обрушилась волна критики: критикующие предлагали компании одуматься и доделать плагин для Scala, вместо того, чтобы разрабатывать свой язык. Разработчикам на Scala действительно очень не хватает хорошей среды разработки, но и проблемы разработчиков плагина можно понять: Scala, которая появилась на свет благодаря исследователям из Швейцарии, вобрала в себя многие инновационные научные концепции и подходы, что сделало создание хорошего инструмента для разработки крайне непростой задачей. На данный момент сегмент современных языков со статической типизацией для JVM невелик, поэтому решение о создании своего языка вместе со средой разработки к нему выглядит очень дальновидным. Даже если этот язык совсем не приживется в сообществе - JetBrains в первую очередь делает его для своих нужд. Эти нужды может понять любой java-программист: Java, как язык, развивается очень медленно, новые возможности в языке не появляются (функции первого порядка мы ждем уже не первый год), совместимость со старыми версиями языка делает невозможным появление многих полезных вещей и в ближайшем будущем (например, приличной параметризации типов). Для компании, разрабатывающей ПО язык программирования - основной рабочий инструмент, поэтому эффективность и простота языка - это показатели, от которых зависит не только простота разработки инструментов для него, но и затраты программиста на кодирование, т. е. насколько просто будет этот код сопровождать и разбираться в нем.

О языке

Язык статически типизирован. Но по сравнению с java, компилятор Kotlin добавляет в тип информацию о возможности ссылки содержать null, что ужесточает проверку типов и делает выполнение более безопасным:

Fun foo(text:String) { println(text.toLowerCase()) // NPE? Нет! } val str:String? = null // String? -- тип допускающий null-ы foo(str) // <- компилятор не пропустит такой вызов -- // тип str должен быть String, чтобы // передать его в foo

Несмотря на то, что такой подход может избавить программиста от ряда проблем связанных с NPE, для java-программиста поначалу это кажется излишним - приходится делать лишние проверки или преобразования. Но через некоторое время программирования на kotlin, возвращаясь на java, чувствуешь, что тебе не хватает этой информации о типе, задумываешься об использовании аннотаций Nullable/NotNull. С этим связаны и вопросы обратной совместимости с java - этой информации в байткоде java нет, но насколько мне известно, этот вопрос еще в процессе решения, а пока все приходящие из java типы - nullable.

Кстати, об обратной совместимости: Kotlin компилируется в байткод JVM (создатели языка тратят много сил на поддержку совместимости), что позволяет использовать его в одном проекте с java, а возможность взаимно использовать классы java и Kotlin делают совсем минимальным порог внедрения Kotlin в большой уже существующий java-проект. В этой связи важна возможность использовать множественные java-наработки, создавая проект целиком на kotlin. Например, мне почти не составило труда сделать небольшой проект на базе spring-webmvc.

Посмотрим фрагмент контроллера:

Path(array("/notes/")) controller class NotesController { private autowired val notesService: NotesService? = null path(array("all")) fun all() = render("notes/notes") { addObject("notes", notesService!!.all) } //... }

Видны особенности использования аннотаций в Kotlin: выглядит местами не так аккуратно, как в java (касается это частных случаев, например, массива из одного элемента), зато аннотации могут быть использованы в качестве «самодельных» ключевых слов как autowired или controller (если задать алиас типу при импорте), а по возможностям аннотации приближаются к настоящим классам.

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

В языке есть поддержка first-class functions. Это значит, что функция - это встроенный в язык тип для которого есть специальный синтаксис. Функции можно создавать по месту, передавать в параметры другим функциям, хранить на них ссылки:

Fun doSomething(thing:()->Unit) { // объявляем параметр типа функция // ()->Unit ничего не принимает и // ничего важного не возвращает thing() // вызываем } doSomething() { // а здесь на лету создаем функцию типа // ()->Unit и передаем её в функцию doShomething // если функция -- последний параметр, можно // вынести её за скобки вызова println("Hello world") }

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

Fun List.filter(condition:(T)->Boolean):List { val result = list() for(item in this) { if(condition(item)) result.add(item) } return result } val someList = list(1, 2, 3, 4).filter { it > 2 } // someList==

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

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

// создание bean-классов становится // немногословным, поля можно объявить // прямо в объявлении конструктора class TimeLord(val name:String) // класс может вообще не иметь тела class TARDIS(val owner:TimeLord) fun main(args:Array) { val doctor = TimeLord("Doctor") val tardis = TARDIS(doctor) println(tardis.owner.name) }

В нескольких строках мы смогли объявить два класса, создать два объекта и вывести имя владельца ТАРДИСа! Можно заметить, что класс объявляется с параметрами своего единственно возможного конструктора, которые одновременно являются и объявлением его свойств. Предельно коротко, но при этом информативно. Наверняка найдутся те, кто осудит невозможность объявить больше одного конструктора, но мне кажется, что в этом есть свой прагматизм - ведь несколько конструкторов в java или позволяют объявить параметры по-умолчанию, что Kotlin поддерживает на уровне языка, или преобразовать один тип к другому, с которым и будет это класс работать, а это уже можно спокойно отдать на откуп фабричному методу. Обратите своё внимание на объявление «переменных» и полей. Kotlin заставляет нас сделать выбор: val или var . Где val - объявляет неизменяемую final -ссылку, а var - переменную, чем помогает избежать повсеместного использования изменяемых ссылок.

Пример

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

Так я бы хотел, чтобы выглядело использование:

Fun main(args: Array) { // создаем небольшое дерево val tree= tree("root") { node("1-1") { node("2-1") node("2-2") } node("1-2") { node("2-3") } } // обходим его и выводим значения в консоль tree.traverse { println(it) } }

Теперь попробуем это реализовать. Создадим класс узла дерева:

/** * @param value данные узла */ class Node(val value:T) { // дети узла private val children:List> = arrayList() /** * Метод, который создает и добавляет ребенка узлу * @param value значение для нового узла * @param init функция инициализации нового узла, необязательный * параметр */ fun node(value:T, init:Node.()->Unit = {}):Node { val node = Node(value) node.init() children.add(node) return node } /** * Метод рекурсивно обходит все дочерние узлы начиная с самого * узла, о каждом узле оповещается обработчик * @param handler функция обработчик для значения каждого узла */ fun traverse(handler:(T)->Unit) { handler(value) children.forEach { child -> child.traverse(handler) } } }

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

/** * Создает вершину дерева со значением value и инициализирует * её детей методом init. */ fun tree(value:T, init:Node.()->Unit): Node { val node = Node(value) // вызываем метод init, переданный в // параметр, на объекте ноды node.init() return node }

В двух местах кода была использована конструкция вида Node.()->Unit, её смысл в том, что на вход ожидается тип-функция, которая будет выполняться как метод объекта типа Node. Из тела этой функции есть доступ к другим методам этого объекта, таким как метод Node.node(), что позволяет сделать инициализацию дерева, подобную описанной в примере.

Вместо заключения

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

Если вас заинтересовал язык, всю информацию о языке можно найти на официальном сайте проекта, ихсодники на github-е, а найденные ошибки постить в Issue Tracker. Проблем пока много, но разработчики языка активно с ними борются. Сейчас команда работает над пока еще не очень стабильной версией milestone 3, после стабилизации, насколько мне известно, планируется использовать язык внутри компании JetBrains, после чего уже планируется выход первого релиза.

Теги: Добавить метки

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

Исторический экскурс

Первое моё знакомство с программированием смартфонов, работающих под управлением операционной системы Android, произошло в начале 2012 года , то есть ровно 6 лет назад. В те далёкие времена Google ещё не создал свою великолепную IDE (Integrated Development Environment, Интегрированная Среда Разработки) Android Studio, и я в IDE Eclipse с установленным плагином ADT (Android Development Tools, Инструменты разработчика Android) . Поводом к знакомству явилась покупка моего первого смартфона HTC Desire HD менее чем за год до этого, в начале лета 2011 года.

Родным языком программирования для Android считалась Java. Это был новый для меня язык, поэтому у меня возникла тройная сложность: новая IDE, новый ЯП и новая ОС (Операционная Система) , и это всё одновременно. Тем не менее, я худо-бедно научился писать программы под Android, и даже написал один коммерческий продукт, за что с удовольствием получил поощрение в €1000.

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

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

В 2014-м году появилась первая стабильная версия IDE от самого Гугла (правда, основанная на IDE IntelliJ IDEA, написанной в юридически Чешской компании JetBrains, основанной в Праге тремя российскими программистами) .

Вообще, всё началось с российской компании StarSoft , которая начала свою деятельность сразу после августовского путча 1991 года на базе лаборатории программного обеспечения при Независимой Гуманитарной Академии в Санкт-Петербурге, и состояла тогда из трёх человек. В 1993 году началась работа над проектом Together (средство проектирования ПО) , идея которого была предложена приехавшим из Германии немцем . В 1995 году компания была переименована в STAR SPb и официально зарегистрировалась как российское представительство STAR Group. В 1999 году из STAR SPb выделилась «российско-немецкая» компания TogetherSoft, состоявшая из специалистов, работавших над продуктом Together. В числе соучредителей как всегда оказались американцы, которые решили, что хороших программистов нужно срочно вывозить из Питера в Европу, и в том же 1999 году топовая команда TogetherSoft (около 50 человек) уехала в Прагу. Среди них были и три будущих основателя компании JetBrains . И вот, в 2000 году ими была основана компания JetBrains, и зарегистрирована там же, где они на тот момент и жили, в Праге.

Флагманским продуктом JetBrains является IntelliJ IDEA — IDE для многих языков программирования. Её то и взял за основу Гугл для своей IDE Android Studio . К слову, сооснователь Гугла тоже из России. Чуть копнёшь — и везде торчат российские корни... Он родился в Москве и жил там до 5 лет, а затем его семья в 1979 году эмигрировала в америку, как тогда это было принято у евреев. Из-за антисемитизма, в частности, наличия квот для евреев для поступления в ВУЗы и университеты. Сначала евреи, как народ, обособляются, всячески подчёркивают свою богоизбранность и не скрывают свой не всегда приемлемый менталитет в регионах с иной доминирующей религией и иным менталитетом, а потом удивляются результату. Впрочем, это уже другая тема. Несмотря на его, мягко говоря, скептическое отношение к своей бывшей родине (а что ещё можно ожидать от человека, воспитанного советскими эмигрантами) , я вполне разделяю его взгляды, в частности, на Интернет. Да и многие критические высказывания в адрес России вполне себе справедливы, хотя и неприятны, будучи слышимы из уст иностранца. Впрочем, я опять отвлёкся...

Итак, когда появилась Android Studio, и я сразу перешёл на неё, как на потенциально более перспективную для разработки под Андроид IDE. Надо сказать, что вначале были заметны как её плюсы, так и минусы по сравнению с Eclipse. Тем не менее плюсов было намного больше, и я прочно подсел на неё.

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

Новый язык программирования Котлин

До недавнего времени Android Studio поддерживала программирование только на языке Java (Джава, ранее чаще говорили Ява. Язык назван в честь марки кофе, которая, в свою очередь, названа в честь острова в Индонезии) и на C++ для нативного кода. Язык Java — не сказать, чтобы очень старый, но, учитывая относительно молодую направленность его применения (мультиплатформенность) , довольно поживший. Он был разработан известной компанией Sun Microsystems в 1995 году. Изначально язык назывался Oak («Дуб») , и разрабатывался для программирования бытовых электронных устройств. Затем он был переименован в Java и стал использоваться для написания клиентских приложений и серверного программного обеспечения. Позже появились и другие его применения.

Замечу, что Java работает в паре с компилятрорм, который не выдаёт полноценный код для его выполнения в операционной системе. Исходные тексты, написанные на этом языке, компилируются в специальный байт-код, который выполняется на специальной виртуальной машине, дополнительно установленной в системе, и переводящей этот код в понятные операционной системе и процессору команды. Таким образом, программы, написанные на этом языке, могут выполняться на любом устройстве, в котором установлена такая виртуальная машина. А виртуальные машины Java написаны уже для самых разных архитектур. Этим и достигается мультиплатформенность программ. Минусом такого подхода является увеличенное время их выполнения за счёт дополнительной прослойки в виде виртуальной машины между кодом и процессором. Также программы на Java зачастую работают медленнее из-за несовершенства многих Java-библиотек, например, библиотек графического интерфейса. Но всё это плата за мультиплатформенность.

И вот, совсем недавно, в конце 2017 года, вышла Android Studio 3.0, которая наряду с языком Java и С++ стала поддерживать язык Kotlin (Котлин) , который, как и Java, предгазначен для создания того же самого байт-кода для той-же виртуальной машины, но имеет другой синтаксис, позволяющий писать намного более компактные исходники. Вместе с тем, файлы с исходниками на обоих языках можно без ограничений смешивать в одном проекте, что даёт возможность постепенно перевести весь проект на Котлин.

Язык совсем свежий. Он начал разрабатываться в 2010 году, был представлен общественности в 2011-м, программировать на нём под Android стало возможным с 2012 года, а официальный релиз был выпущен совсем недавно, в 2016 году. Кстати, по традиции (как и Java) язык назван в честь острова. На этот раз это российский остров Котлин в Финском заливе, на котором расположен город Кронштадт. А разработан язык питерскими программистами всё в той же компании JetBrains! О как, реальный российский язык программирования! [Патриотам размахивать флагами, а автор этого поста уже вовсю ходит кругами по комнате, грозно помахивая древком...]

Я уже попробовал писать на этом языке под Android, и могу с уверенностью заявить, что язык вполне себе годный. Ранее я терялся в Java-коде, потому что в Android надо прописывать всё и вся, и получались очень длинные простыни исходников. В итоге исходники разрастались до неприличных размеров, и их приходилось мелко дробить на классы, распихивая их в разные файлы, и тогда я уже терялся в файлах. В Kotlin же используется философия «всё, что можно сгенерировать автоматически, надо генерировать автоматически». С одной стороны, код становится менее прозрачный (минус, но, разве что, только для новичков) , но более простой и компактный (большой плюс для всех).

Компактность кода достигается не только за счёт сокращённых конструкций синтаксиса, но и за счёт штатных библиотек, способ применения которых специально заточен на компактность и эргономичность использования. Примером этому могут служить сопрограммы (или, как калька с английского, корутины) . Сопрограммы — это очень понятный компактный способ оформления кода, который должен выполняться асинхронно основному потоку. Никаких дополнительных классов с методами отдельно прописывать не надо, всё делается прямо в основном коде, и это прекрасно! Кроме того, сопрограммы реализованы на уровне самой библиотеки, и не создают тяжеловесных системных потоков. Их даже называют легковесными потоками. Поэтому ограничений на их одновременно запущенное количество практически не существует. Сопрограммы бесподобны!

Архитектурные компоненты для Android от Google

Также очень компактным оказалось создание и использование базы данных SQLite с помощью библиотеки Room , являющейся обёрткой над известным классом SQLiteOpenHelper. Для использования Room достаточно описать два маленьких класса, описывающих таблицу и базу данных и один маленький интерфейс, описывающий функции взаимодействия с этой базой данных. Это всё в Котлине даже нет необходимости рассовывать в разные файлы. На основе этой мизерной информации Room воспроизведёт все действия, которые раньше приходилось расписывать в огромных файлах, автоматически и внутри себя. Чудеса!

В реальных приложениях нужно отслеживать изменения данных в базе и автоматически обновлять информацию в визуальных компонентах. Поэтому компонент Room чаще всего используется не сам по себе, а вместе с компонентом LiveData из библиотеки android.arch.lifecycle . Этот компонент также используется элементарно. Данные, которые необходимо отслеживать, передаются из базы в переменную не напрямую, а в виде класса LiveData, принявшего внутри Room эти данные в виде параметра. После этого в основном коде одной строкой Котлина задаётся наблюдение за ними и функция обновления визуального компонента, которая запускается при изменении данных. Всё элементарно!

Ещё один полезный компонент из библиотеки android.arch.lifecycle , решающий головную боль с сохранением данных активности при поворотах экрана — ViewModel. Раньше приходилось писать всякие хитроумные костыли для того, чтобы данные не терялись, а вычисления не прерывались. Теперь для этого есть официальный компонент! Если раньше мы отделяли интерфейс от кода (разметка и активность) , то теперь настало время отелять код, который должен работать только в период жизненного цикла активности (например, обеспечение функционирования интерфейса с пользователем) , от кода, который должен работать вне привязки к конкретному жизненному циклу активности (например, получение, обработка и передача данных) . При этом результат работы второй части кода мы можем автоматически прочитать в пересозданной после поворота экрана активности.

Для реализации всей этой схемы с ViewModel тоже требуется минимум действий. Пишется отдельный класс с кодом, который не должен прерываться (т.н. модель вида, почему «модель» — не знаю; может, перевожу неправильно) , а в основном коде одной строкой вызывается провайдер моделей, в который этот класс передаётся в качестве параметра. Провайдер либо возвращает существующий объект класса модели (после поворота экрана) , либо создаёт такой объект по переданному классу, если такового ещё нет, и тоже возвращает его (при первом запуске активности) . Активность всегда может обращаться к функциям и переменным этого объекта.

Все три компонента объединены под официальным названием Android Architecture Components (Архитектурные Компоненты для Android). Правда, туда ещё входит компонент LifeCycle, тоже находящийся в библиотеке android.arch.lifecycle , но он используется в плотной связке с LiveData, и я бы его вообще не выделял. Появление таких высокоуровневых компонентов — долгожданный шаг Google в правильном направлении. Я давно уже ругался на то, как много разных классов нужно расширить самому и соединить их все друг с другом, чтобы заставить работать что-то чуть большее, чем примитивные примеры из учебников для начинающих. И вот, наконец, среди библиотек стали появляться правильные компоненты. Надеюсь, что эта тенденция продолжится.

Визуальный редактор интерфейса

На этом обнаруженные мною новшества в программировании смартфонов не заканчиваются. С самого рождения в Android Studio было очень тяжко со стабильностью и предсказуемостью работы визуального редактора интерфейса, хотя он и был постабильнее, чем в Eclipse. Даже непосредственно редактируя xml-разметку интерфейса, очень сложно было настроить все эти Layout"ы и другие визуальные компоненты так, чтобы они отображались в нужных местах и в нужном виде.

К счастью, в Android Studio, начиная с версии 2.2, вместо гиморного построения интерфейса через макеты линейного расположения элементов (LinearLayout) предлагается использовать новый макет принудительного расположения (ConstraintLayout) . Кроме того, визуальный редактор, наконец, доведён до ума. Всё это вместе дало очень положительный эффект. Теперь правильно расположить элементы не так сложно, и ведут они себя вполне предсказуемо.Теперь можно даже не трогать xml-разметку, а все действия выполнять в визуальном редакторе.

Язык программирования Kotlin, разработанный петербургской компанией JetBrains, стал официальным языком разработок для Android. Об этом официально объявили на конференции Google I/O. Командой Kotlin руководит выпускник Университета ИТМО Андрей Бреслав. Почему именно Kotlin так полюбился IT-гиганту среди многих других «молодых» языков, как и зачем вообще появляются новые языки программирования, читайте в комментариях экспертов и информационной подборке ITMO.NEWS.

Как разрабатываются языки программирования

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

«Программисты не были абсолютно довольны языками С++ и Java, потому что это достаточно сложные языки, при этом первый сложнее, чем второй. Поэтому появился язык Scala, который нравится многим программистам, но и он весьма сложен. Огромный опыт компании JetBrains в создании средств разработки программ для разных языков программирования позволил за семь лет создать язык Kotlin, который полностью совместим с Java, но проще и удобнее его. Языки программирования разрабатываются постоянно, задачу сделать универсальный язык уже никто перед собой не ставит. Несмотря на это, каждый язык более эффективен в определенной области, где его чаще всего и используют. Есть даже такое направление в создании языков, когда они разрабатываются под конкретную предметную область », - прокомментировал заведующий кафедрой технологии программирования Университета ИТМО .

Сегодня некоторые компании даже составляют свои рейтинги языков. Например, компания TIOBE, которая специализируется в оценке качества программного обеспечения, ежемесячно вычисляет индекс популярности тех или иных языков с 2001 года. В генерируемом списке 50 строчек, и чтобы язык программирования попал в индекс, разработчики должны написать соответствующее письмо в компанию. Подсчет ведется на основе данных 25 поисковых Интернет-систем. Пока в рейтинге с большим отрывом лидирует Java, за ней идет С. При этом составители списка подчеркивают, что за последний год оба языка программирования стали менее популярными, примерно на 6%. При этом TIOBE показывает, что язык С был языком №1 вплоть до 2002 года, а Java в 1997 году была на 14 месте, но уже через пять лет заменил С на первой позиции.

Отличную лекцию по истории развития языков можно : о том, как появились языки С, PHP, Ruby и Java рассказывает куратор академических программ «Яндекса», директор центра студенческих олимпиад факультета компьютерных наук ВШЭ Михаил Густокашин . Лектор подчеркивает, что для каждой задачи следует выбирать разный язык программирования. Например, он говорит, что для военной промышленности лучше всего писать на старом-добром Pascal - языке, который родился еще в 1970 году! Почему? Потому что он надежней. Приложения для бизнеса можно писать на Java, потому что этот язык тоже достаточно надежен, но гораздо более прост в использовании. Эксперт также подчеркивает, что важно поддерживать интерес к языку среди программистов с помощью создания сообщества разработчиков, которые пишут на этом языке. Если вокруг какого-нибудь нового языка создается инфраструктура, собираются люди, которые им пользуются, только тогда язык станет популярным. Кстати, разработчики Kotlin тоже взяли на вооружение эту стратегию.

Немного о Kotlin

Язык программирования Kotlin начал разрабатываться в петербургской компании JetBrains в 2010 году. Официальный релиз продукта был выпущен в 2016 году. Такое название язык получил в честь острова в Финском заливе, на котором расположен Кронштадт. По интересному совпадению, название популярного языка Java - это тоже имя острова в Индонезии. Вероятно, совпадение не случайно. Как сообщается в пресс-релизе, Kotlin должен работать везде, где работает Java, и один из ориентиров был сделать такой продукт, который можно будет использовать в смешанных проектах, которые создаются на нескольких языках.

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

«Инструменты разработки, включая языки программирования, постоянно развиваются. Языки отличаются от других инструментов тем, что их довольно сложно развивать эволюционно. Новая версия языка должна поддерживать все уже существующие программы. Это ограничивает возможности развития существующих языков и создает потребность в появлении новых. Фактор, который определяет успешность нового языка программирования, это, в первую очередь, удобство для разработчиков. Кроме краткости и выразительности, Kotlin хорошо совместим с кодом на Java: можно использовать все существующие библиотеки и даже смешивать код на двух языках в одном проекте, поэтому не возникает особенных сложностей с переходом », - прокомментировал , руководитель проекта Kotlin в JetBrains, выпускник Университета ИТМО.

Почему Google полюбил Kotlin

На официальном сайте разработчики Android пишут, что они наблюдали «восхождение» Kotlin все последние годы. «Гуглеры» не стесняются описывать этот язык как впечатляющий и лаконичный, который отрывает больше возможностей и с которым приятно работать. Он обладает повышенной производительностью: программный код на нем получается в среднем на 40% короче, чем на других языках, а также Kotlin позволяет не допускать некоторые ошибки в коде. Одним из определяющих факторов популярности Kotlin в Google стало то, что он совместим с Java, который уже используется при разработке приложений под Android.

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

«Отсутствие гарантий поддержки языка со стороны Google отпугивало многих разработчиков от перехода на Kotlin. Даже если язык очень нравится, программист всегда думает о риске, что в какой-то момент этот язык просто перестанет работать. Теперь есть гарантия того, что работать Kotlin не перестанет, и мы ожидаем, что количество пользователей языка резко возрастет. Было бы естественно предположить, что многие компании со временем перейдут на Kotlin полностью, хотя технически их к этому ничего не вынуждает, это просто вопрос предпочтений », - подчеркнул Андрей Бреслав.

Он добавил, что Kotlin очень активно развивается. Команда разработчиков сейчас работает над билд-системой, скоростью компиляции, улучшает производительность IDE, добавляет в инструментарий новые возможности, в том числе связанные с интеграцией в Android Studio. Также идет работа над мультиплатформенными проектами (возможность компилировать один и тот же код под несколько платформ), целый ряд языковых улучшений находится в стадии дизайна.

В Google также подчеркнули, что их вдохновляет концепт языка Kotlin, по которому он всегда был и останется бесплатным для разработчиков, то есть open source project. Это значит, что язык не привязан к какой-либо отдельной компании, а исходный код распространяется под свободной лицензией. Загрузить продукт можно . Чтобы поддерживать развитие Kotlin, компаниями Google и JetBrains будет создано некоммерческое партнерство. Также в рамках «миссии» Android очень важно, что авторы Kotlin создают вокруг своего продукта сообщество людей, которые профессионально занимаются разработкой на этом языке и любят делиться опытом. Например, в ноябре в США состоится конференция Kotlin , также разработчики могут получать ежедневные новости и советы о программном продукте, встречаться на местном уровне.

Кстати, сам проект Android Studio был разработан на базе программной среды разработки IntelliJ IDEA, которую также создали в компании JetBrains. Но несмотря на тесной сотрудничество, в петербургской компании подчеркивают, что ни о какой продаже JetBrains американскому IT-гиганту речи не идет. При этом Koltin не будет заточен только под Android. Цель компании - сделать язык программирования подходящим под разные платформы разработки.

Последнее обновление: 02.12.2017

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

Kotlin работает поверх виртуальной машины Java (JVM) и при компиляции компилируется в байткод. То есть, как и в случае с Java, мы можем запускать приложение на Kotlin везде, где установлена JVM. Хотя также можно компилировать код в JavaScript и запускать в браузере. И, кроме того, можно компилировать код Kotlin в нативные бинарные файлы, которые будут работать без всякой виртуальной машины. Таким образом, круг платформ, для которых можно создавать приложения на Kotlin, чрезвычайно широк - Windows, Linux, Mac OS, iOS, Android.

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

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

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

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

По выше указанному адресу можно найти архив. Загрузим и распакуем из архива папку kotlinc. В распакованном архиве в папке bin мы можем найти утилиту kotlinc , с помощью которой и будет производиться компиляция:

Теперь определим на жестком диске каталог для файлов с исходным кодом. Например, в моем случае каталог будет находиться по пути c:/kotlin . В этом каталоге создадим текстовый файл и переименуем его в app.kt . Расширение kt - это арсширение файлов на языке Kotlin.

Fun main(args: Array){ println("Hello Kotlin") }

В данном случае мы определяем функцию main, которая и будет представлять действия, выполняемые программой. Для определения функции применяется ключевое слово fun .

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

Внутри функции main выполняется другая функция - println() , которая выводит некоторое сообщение на консоль.

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

C:\kotlin\bin\kotlinc app.kt -include-runtime -d app.jar

В данном случае мы передаем компилятору c:\kotlin\bin\kotlinc для компиляции файл app.kt. (Чтобы не писать полный путь к компилятору, путь к нему можно добавить в переменную PATH в переменных среды). Далее с помощью параметра -include-runtime указывается, что создаваемый файл будет включать среду Kotlin. А параметр -d указывает, как будет называться создаваемый файл приложения, то есть в данном случае это будет app.jar .

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

Java -jar app.jar

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

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

В 2010 году группа разработчиков российского отделения JetBrains взялась за разработку языка, который был бы удобнее и типобезопаснее, чем Java, но не так сложен, как Scala. Название этому языку было дано в честь острова Котлин, расположенного в Финском заливе (по аналогии с Java, который также назван в честь острова).

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

Синтаксис

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

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

Впрочем, небольшой кусочек кода всё же оставим:

fun main(args: Array) {
val scope = "world"
println("Hello, $scope!")
}

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

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

Преимущества

В общем-то все преимущества в сравнении с Java уже были названы, поэтому просто соберем их в одном месте:

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

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

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

Недостатки

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

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

Перспективы

Несмотря на то, что разработка Kotlin началась в 2010 году, первая официальная версия увидела свет лишь в феврале 2016. С этого момента востребованность языка стремительно растет, в рейтинге TIOBE он за год ворвался в TOP-50, а в прошлом месяце на конференции Google I/O было объявлено об официальной поддержке Kotlin в системе разработки Android-приложений.

Учитывая высокую популярность IntelliJ IDEA среди разработчиков и стратегическую ставку компании на Kotlin, можно с уверенностью утверждать, что через 3-4 года мы увидим его среди полноправных конкурентов Java и Swift в области мобильной разработки. Кроме того, если создатели языка не разочаруются в своем продукте, наверняка Kotlin отправится всерьез захватывать и другие горизонты: веб, ИИ, интернет вещей, большие данные, десктопные приложения.

Если вас всерьёз заинтересовал этот язык, то обязательно загляните на его официальный сайт (русская версия) и испытайте все его преимущества на личном опыте. Спешите, пока это не стало мейнстримом.