Cet article parle du langage de programmation Kotlin. Vous découvrirez les raisons de l'émergence du projet, les capacités du langage et verrez plusieurs exemples. L'article a été écrit principalement dans l'espoir que le lecteur soit familier avec le langage de programmation Java, cependant, ceux qui connaissent un autre langage pourront également se faire une idée sur le sujet. L'article est superficiel et n'aborde pas les problèmes liés à la compilation en javascript. Vous pouvez trouver une documentation complète sur le site officiel du projet, mais je vais essayer de parler brièvement du langage.
À propos du projet
Il n'y a pas si longtemps, JetBrains, une société qui crée des environnements de développement, a annoncé son nouveau produit : le langage de programmation Kotlin. Une vague de critiques a frappé l'entreprise : les critiques ont suggéré que l'entreprise reprenne ses esprits et complète le plugin pour Scala, au lieu de développer son propre langage. Les développeurs Scala manquent vraiment d'un bon environnement de développement, mais les problèmes des développeurs de plugins sont compréhensibles : Scala, né grâce à des chercheurs suisses, a intégré de nombreux concepts et approches scientifiques innovants, ce qui a rendu la création d'un bon outil de développement une tâche extrêmement difficile. . À l'heure actuelle, le segment des langages modernes à typage statique pour la JVM est petit, donc la décision de créer votre propre langage ainsi qu'un environnement de développement pour celui-ci semble très prévoyante. Même si ce langage ne prend pas du tout racine dans la communauté, JetBrains le fabrique avant tout pour ses besoins. Tout programmeur Java peut comprendre ces besoins : Java en tant que langage se développe très lentement, de nouvelles fonctionnalités n'apparaissent pas dans le langage (on attend déjà des fonctions de premier ordre depuis plusieurs années déjà), la compatibilité avec les anciennes versions du langage le rend impossible que de nombreuses choses utiles apparaissent dans un avenir proche (par exemple, un paramétrage de type décent). Pour une entreprise développant des logiciels, le langage de programmation est le principal outil de travail, donc l'efficacité et la simplicité du langage sont des indicateurs dont dépend non seulement la facilité de développement d'outils, mais aussi les coûts de codage du programmeur, c'est-à-dire la facilité avec laquelle il sera être de maintenir ce code et de le comprendre.À propos de la langue
Le langage est typé statiquement. Mais par rapport à Java, le compilateur Kotlin ajoute des informations au type indiquant si la référence peut contenir null, ce qui renforce la vérification du type et rend l'exécution plus sûre :Fun foo(text:String) ( println(text.toLowerCase()) // NPE ? Non ! ) val str:String ? = nul // Chaîne ? -- type nullable foo(str) //<- компилятор не пропустит такой вызов -- // тип str должен быть String, чтобы // передать его в foo
Malgré le fait que cette approche puisse éviter au programmeur un certain nombre de problèmes associés à NPE, pour un programmeur Java, cela semble au début inutile - vous devez effectuer des vérifications ou des conversions inutiles. Mais après un certain temps de programmation en Kotlin, de retour à Java, vous sentez qu'il vous manque ces informations sur le type et vous pensez à utiliser les annotations Nullable/NotNull. À cela s'ajoutent des problèmes de compatibilité ascendante avec Java - ces informations ne figurent pas dans le bytecode Java, mais pour autant que je sache, ce problème est toujours en cours de résolution et pour l'instant, tous les types provenant de Java sont nullables.
Au fait, à propos de la rétrocompatibilité : Kotlin est compilé en bytecode JVM (les créateurs du langage consacrent beaucoup d'efforts au maintien de la compatibilité), ce qui lui permet d'être utilisé dans le même projet avec Java, et la possibilité d'utiliser Java mutuellement. et les classes Kotlin constituent le seuil pour introduire Kotlin dans un grand projet Java existant très minimal. À cet égard, la possibilité d'utiliser plusieurs développements Java en créant un projet entièrement en Kotlin est importante. Par exemple, il m'a été presque facile de réaliser un petit projet basé sur spring-webmvc.
Regardons le fragment du contrôleur :
Path(array("/notes/")) classe de contrôleur NotesController (private autowired val notesService: NotesService? = null path(array("all")) fun all() = render("notes/notes") ( addObject(" notes", notesService!!.all) ) //... )
Les particularités de l'utilisation des annotations dans Kotlin sont visibles : à certains endroits, cela n'a pas l'air aussi soigné qu'en Java (cela s'applique à des cas particuliers, par exemple, un tableau d'un élément), mais les annotations peuvent être utilisées comme des mots-clés « faits maison » tels que en tant qu'autowired ou contrôleur (si vous spécifiez un type d'alias lors de l'importation), et en termes de capacités, les annotations sont plus proches des classes réelles.
Il convient de noter que Spring n'a pas pu envelopper les classes Kotlin pour gérer les transactions - j'espère que cela sera possible à l'avenir.
Le langage prend en charge des fonctions de première classe. Cela signifie qu'une fonction est un type intégré au langage pour lequel il existe une syntaxe spéciale. Les fonctions peuvent être créées localement, transmises en tant que paramètres à d'autres fonctions, et les références à celles-ci peuvent être stockées :
Fun doSomething(thing:()->Unit) ( // déclare un paramètre de type fonction // ()->Unit n'accepte rien et // ne renvoie rien d'important() // appelle ) doSomething() ( // et ici à la volée nous créons une fonction de type //()->Unit et la passons à la fonction doShomething // si la fonction est le dernier paramètre, vous pouvez // la déplacer en dehors des parenthèses d'appel println("Bonjour tout le monde ") )
Si nous ajoutons à cette extension des fonctions qui nous permettent d'étendre une classe déjà existante à l'aide d'une méthode qui ne viole pas l'encapsulation de la classe, mais accessible en tant que méthodes de cette classe, alors nous obtiendrons un mécanisme d'extension assez puissant. bibliothèques Java standard assez médiocres en termes de commodité. Par tradition, ajoutons la possibilité de filtrer la liste qui existe déjà dans la bibliothèque standard :
Amusant
Veuillez noter que les types des variables n'ont pas été spécifiés - le compilateur Kotlin les déduit si possible et n'interfère pas avec la compréhensibilité de l'interface. De manière générale, le langage est conçu de manière à éviter au maximum à la personne au clavier de taper des caractères inutiles : syntaxe courte mais claire avec un minimum de mots-clés, pas besoin de points-virgules pour séparer les expressions, tapez l'inférence le cas échéant. , pas de nouveau mot-clé pour créer une classe - seulement ce qui est nécessaire.
Pour illustrer le sujet des classes et de la brièveté, regardons le code suivant :
// la création de classes de bean devient // laconique, les champs peuvent être déclarés // directement dans la déclaration du constructeur class TimeLord(val name:String) // la classe peut ne pas avoir de corps du tout class TARDIS(valowner:TimeLord) fun main (arguments : tableau
En quelques lignes, nous avons pu déclarer deux classes, créer deux objets, et afficher le nom du propriétaire du TARDIS ! Vous pouvez remarquer que la classe est déclarée avec les paramètres de son seul constructeur possible, qui sont aussi la déclaration de ses propriétés. Extrêmement court, mais instructif. Il y aura sûrement ceux qui condamneront l'impossibilité de déclarer plus d'un constructeur, mais il me semble que cela a son propre pragmatisme - après tout, plusieurs constructeurs en Java vous permettent soit de déclarer les paramètres par défaut, que Kotlin prend en charge au niveau du langage niveau, ou convertir un type en un autre, avec lequel cette classe fonctionnera, et cela peut déjà être laissé en toute sécurité à la méthode d'usine. Faites attention à la déclaration des « variables » et des champs. Kotlin nous oblige à faire un choix : val ou var . Où val déclare une référence finale immuable et var déclare une variable, ce qui permet d'éviter l'utilisation généralisée de références mutables.
Exemple
Nous avons maintenant atteint le point où nous pouvons faire quelque chose de plus intéressant. Lors des entretiens, je donne souvent pour tâche d'implémenter un arbre, de le parcourir et de déterminer une action avec un élément. Voyons comment cela est implémenté dans Kotlin.Voici à quoi j'aimerais que l'utilisation ressemble :
Principal amusant (arguments : Array
Essayons maintenant de mettre en œuvre cela. Créons une classe de nœuds d'arbre :
/** * Données du nœud de valeur @param */ Noeud de classe
Ajoutons maintenant une fonction pour créer le sommet de l'arborescence :
/** * Crée un nœud d'arborescence avec valeur value et initialise * ses enfants avec la méthode init.
( val node = Node(value) // appelle la méthode init passée dans le // paramètre sur le nœud objet node.init() return node )
À deux endroits du code, une construction comme Node.()->Unit a été utilisée, sa signification est qu'un type de fonction est attendu en entrée, qui sera exécuté comme méthode d'un objet de type Node. Depuis le corps de cette fonction, on accède à d'autres méthodes de cet objet, comme la méthode Node.node(), qui permet d'effectuer une initialisation d'arborescence similaire à celle décrite dans l'exemple.
Au lieu d'une conclusion
Si la langue vous intéresse, toutes les informations sur la langue peuvent être trouvées sur le site officiel du projet, leurs sources peuvent être trouvées sur github et toutes les erreurs trouvées peuvent être publiées dans Issue Tracker. Il existe encore de nombreux problèmes, mais les développeurs de langages les combattent activement. Maintenant, l'équipe travaille sur la version encore pas très stable du jalon 3, après stabilisation, à ma connaissance, il est prévu d'utiliser le langage au sein de la société JetBrains, après quoi la première version est déjà prévue.
Balises : Ajouter des balises
En 2017, il y a eu un nouveau battage médiatique autour de YP (Langage de programmation) Kotlin, et dans ce contexte, je souhaite également vous parler d'autres innovations dans le développement de programmes pour smartphones basés sur le système d'exploitation Android. Mais ceci est mon blog personnel, et non une sorte de ressource académique, et donc, d'abord, je vais me permettre quelques digressions lyriques de côté, en tournant mon regard vers le passé.
Excursion historique
Ma première connaissance de la programmation de smartphones exécutant le système d'exploitation Android a été au début de 2012, c'est-à-dire il y a exactement 6 ans. En ces temps lointains, Google n'avait pas encore créé son magnifique IDE (Environnement de développement intégré, environnement de développement intégré) Android Studio et je suis dans Eclipse IDE avec le plugin ADT installé (Outils de développement Android, outils de développement Android). La raison de notre connaissance était l'achat de mon premier smartphone, le HTC Desire HD, moins d'un an plus tôt, au début de l'été 2011.
Java était considéré comme le langage de programmation natif d’Android. C'était un nouveau langage pour moi, j'avais donc un triple défi : un nouvel IDE, un nouveau langage et un nouvel OS (Système opérateur), et tout cela en même temps. Néanmoins, j'ai appris d'une manière ou d'une autre à écrire des programmes pour Android et j'ai même écrit un produit commercial pour lequel j'ai reçu avec plaisir une récompense de 1 000 €.
Cependant, la programmation pour Android était extrêmement gênante, ce que je mentionne même périodiquement. Voici l'imperfection de l'IDE, et le sous-développement des bibliothèques standards en direction d'Android, et elles, et les problèmes de tout cela séparément.
Encore un an plus tard début 2013 J'ai même commencé à écrire un blog spécial intitulé « Android, des tours avec tes oreilles » avec l'épigraphe caractéristique « Les hérissons pleuraient, se piquaient, mais continuaient à ronger le cactus...", dans lequel je publiais périodiquement des solutions à certains problèmes que j'avais rencontrés, et publiais également des informations générales supplémentaires, comme pour ma mémoire.
En 2014 La première version stable de l'IDE de Google lui-même est apparue (bien que basé sur l'IDE IntelliJ IDEA, écrit dans la société légalement tchèque JetBrains, fondée à Prague par trois programmeurs russes).
En général, tout a commencé avec la société russe StarSoft, qui a commencé ses activités immédiatement après le coup d'État d'août 1991 sur la base du laboratoire logiciel de l'Académie humanitaire indépendante de Saint-Pétersbourg, et qui comptait alors trois personnes. En 1993, les travaux commencent sur le projet Together (outil de conception de logiciels), dont l'idée a été proposée par un Allemand venu d'Allemagne. En 1995, la société a été rebaptisée STAR SPb et officiellement enregistrée en tant que bureau de représentation russe du groupe STAR. En 1999, la société « russo-allemande » TogetherSoft, composée de spécialistes ayant travaillé sur le produit Together, s'est séparée de STAR SPb. Parmi les cofondateurs, comme toujours, se trouvaient des Américains qui ont décidé qu'il fallait de toute urgence emmener de bons programmeurs de Saint-Pétersbourg vers l'Europe, et dans le même 1999, la meilleure équipe de TogetherSoft (environ 50 personnes) est allé à Prague. Parmi eux se trouvaient les trois futurs fondateurs de JetBrains. C'est ainsi qu'en 2000, ils fondèrent la société JetBrains et s'enregistrèrent au même endroit où ils vivaient à l'époque, à Prague.
Le produit phare de JetBrains est IntelliJ IDEA, un IDE pour de nombreux langages de programmation. Google l'a pris comme base pour son IDE Android Studio. À propos, le co-fondateur de Google est également originaire de Russie. Si l'on creuse un peu, les racines russes ressortent partout... Il est né à Moscou et y a vécu jusqu'à l'âge de 5 ans, puis sa famille a émigré en Amérique en 1979, comme c'était alors la coutume parmi les Juifs. En raison de l'antisémitisme, en particulier, la présence de quotas pour les juifs pour entrer dans les universités. Au début, les Juifs, en tant que peuple, s'isolent, soulignent de toutes les manières possibles leur choix de Dieu et ne cachent pas leur mentalité pas toujours acceptable dans des régions avec une religion dominante différente et une mentalité différente, puis ils sont surpris du résultat. . Cependant, c'est un autre sujet. Malgré son attitude, pour le moins, sceptique à l'égard de son ancienne patrie (que pouvez-vous attendre d'autre d'une personne élevée par des émigrés soviétiques), je partage entièrement son point de vue, notamment sur Internet. Et de nombreuses déclarations critiques à l’égard de la Russie sont tout à fait justes, même si elles sont désagréables lorsqu’elles sont entendues par un étranger. Cependant, j'ai encore été distrait...
Ainsi, lorsque Android Studio est apparu, je l'ai immédiatement adopté comme un IDE potentiellement plus prometteur pour le développement pour Android. Je dois dire qu'au début, ses avantages et ses inconvénients par rapport à Eclipse étaient perceptibles. Néanmoins, il y avait bien d’autres avantages et j’en suis devenu fermement accro.
En tant qu'amateur, je programme de manière irrégulière, et j'ai complètement raté la dernière année 2017 en termes d'Android. Et maintenant, j'ai décidé de mettre à jour l'EDI et de voir quelles nouveautés y sont apparues entre-temps. Et il s’est avéré que beaucoup de choses significatives y sont apparues ! Ci-dessous, je vais énumérer quelques innovations particulièrement remarquables que j’évalue très positivement.
Nouveau langage de programmation Kotlin
Jusqu'à récemment, Android Studio ne prenait en charge que la programmation en Java (Java, auparavant plus souvent appelé Java. Le langage porte le nom d'une marque de café, qui, à son tour, porte le nom d'une île d'Indonésie) et en C++ pour le code natif. Le langage Java n'est pas très ancien, mais étant donné son utilisation relativement jeune (multiplateforme), assez âgé. Il a été développé par la célèbre société Sun Microsystems en 1995. La langue s'appelait à l'origine Oak ("Chêne"), et a été développé pour la programmation d'appareils électroniques grand public. Il a ensuite été renommé Java et utilisé pour écrire des applications client et des logiciels serveur. Plus tard, d’autres usages sont apparus.
Je remarque que Java fonctionne en tandem avec un compilateur, qui ne produit pas de code complet pour son exécution dans le système d'exploitation. Les textes sources écrits dans ce langage sont compilés dans un bytecode spécial, qui est exécuté sur une machine virtuelle spéciale, installée en outre sur le système, qui traduit ce code en commandes compréhensibles par le système d'exploitation et le processeur. Ainsi, les programmes écrits dans ce langage peuvent être exécutés sur n'importe quel appareil sur lequel une telle machine virtuelle est installée. Et les machines virtuelles Java ont déjà été écrites pour diverses architectures. C'est ainsi que sont réalisés les programmes multiplateformes. L'inconvénient de cette approche est l'augmentation du temps d'exécution due à une couche supplémentaire sous la forme d'une machine virtuelle entre le code et le processeur. De plus, les programmes Java s'exécutent souvent plus lentement en raison des imperfections de nombreuses bibliothèques Java, par exemple les bibliothèques GUI. Mais tout cela est le prix du multiplateforme.
Et tout récemment, fin 2017, Android Studio 3.0 est sorti, qui, avec les langages Java et C++, a commencé à prendre en charge le langage Kotlin. (Kotlin), qui, comme Java, est conçu pour créer le même bytecode pour la même machine virtuelle, mais a une syntaxe différente qui vous permet d'écrire un code source beaucoup plus compact. Dans le même temps, les fichiers sources dans les deux langues peuvent être mélangés sans restrictions dans un seul projet, ce qui permet de transférer progressivement l'ensemble du projet vers Kotlin.
La langue est complètement nouvelle. Son développement a commencé en 2010, a été présenté au public en 2011, la programmation pour Android est devenue possible en 2012 et la version officielle a été publiée assez récemment, en 2016. D'ailleurs, selon la tradition (identique à Java) la langue porte le nom de l'île. Il s’agit cette fois de l’île russe de Kotlin, dans le golfe de Finlande, sur laquelle se trouve la ville de Kronstadt. Et le langage a été développé par des programmeurs de Saint-Pétersbourg, tous dans la même société JetBrains ! Oh, comment, un vrai langage de programmation russe ! [Les patriotes devraient agiter des drapeaux, et l'auteur de ce message tourne déjà en rond dans la pièce, agitant le bâton de manière menaçante...]
J'ai déjà essayé d'écrire dans cette langue pour Android et je peux affirmer avec certitude que la langue est tout à fait appropriée. Auparavant, j'étais perdu dans le code Java, car sous Android, il faut écrire tout et tout le monde, et on se retrouvait avec de très longues feuilles de code source. En conséquence, le code source a atteint des tailles obscènes et a dû être finement divisé en classes, inséré dans différents fichiers, puis j'étais déjà perdu dans les fichiers. Kotlin utilise la philosophie « tout ce qui peut être généré automatiquement doit être généré automatiquement ». D'une part, le code devient moins transparent (moins, mais peut-être seulement pour les débutants), mais plus simple et plus compact (un gros plus pour tout le monde).
La compacité du code est obtenue non seulement grâce à des structures syntaxiques abrégées, mais également grâce à des bibliothèques standards dont la méthode d'utilisation est spécialement adaptée pour la compacité et l'ergonomie. Un exemple de ceci serait les coroutines (ou, comme papier calque de l'anglais, coroutines). Les coroutines sont une manière très claire et compacte de formater le code qui doit être exécuté de manière asynchrone par le thread principal. Il n’est pas nécessaire d’écrire des classes supplémentaires avec des méthodes séparément ; tout est fait correctement dans le code principal, et c’est génial ! De plus, les coroutines sont implémentées au niveau de la bibliothèque elle-même et ne créent pas de threads système lourds. On les appelle même des fils légers. Par conséquent, il n’y a pratiquement aucune restriction quant au nombre d’entre eux lancés simultanément. Les coroutines sont incroyables !
Composants architecturaux pour Android de Google
Il s'est également avéré très compact de créer et d'utiliser une base de données SQLite à l'aide de la bibliothèque Room, qui est un wrapper sur la classe bien connue SQLiteOpenHelper. Pour utiliser Room, il suffit de décrire deux petites classes qui décrivent la table et la base de données et une petite interface qui décrit les fonctions d'interaction avec cette base de données. Dans Kotlin, il n'est pas nécessaire de mettre tout cela dans différents fichiers. Sur la base de ces rares informations, Room reproduira automatiquement et en interne toutes les actions qui devaient auparavant être écrites dans d'énormes fichiers. Des miracles !
Dans les applications réelles, vous devez suivre les modifications des données dans la base de données et mettre automatiquement à jour les informations dans les composants visuels. Par conséquent, le composant Room n'est le plus souvent pas utilisé seul, mais avec le composant LiveData de la bibliothèque android.arch.lifecycle. Ce composant est également facile à utiliser. Les données qui doivent être suivies sont transférées de la base de données vers la variable non pas directement, mais sous la forme de la classe LiveData, qui a reçu ces données en tant que paramètre dans Room. Après cela, dans le code principal, une ligne de Kotlin définit leur surveillance et la fonction de mise à jour du composant visuel, qui est lancée lorsque les données changent. Tout est élémentaire !
ViewModel est un autre composant utile de la bibliothèque android.arch.lifecycle qui résout le problème de la sauvegarde des données d'activité lors de la rotation de l'écran. Auparavant, il fallait écrire toutes sortes de béquilles ingénieuses pour que les données ne soient pas perdues et que les calculs ne soient pas interrompus. Il existe désormais un composant officiel pour cela ! Si plus tôt nous séparions l'interface du code (balisage et activité), il est maintenant temps de séparer le code qui ne doit s'exécuter que pendant le cycle de vie de l'activité (par exemple, assurer le fonctionnement de l'interface utilisateur), à partir du code qui doit s'exécuter en dehors d'un cycle de vie d'activité spécifique (par exemple, recevoir, traiter et transmettre des données). Dans ce cas, on peut lire automatiquement le résultat de la deuxième partie du code dans l'activité recréée après rotation de l'écran.
Pour mettre en œuvre l'ensemble de ce schéma avec ViewModel, un minimum d'actions est également requis. Une classe distincte est écrite avec du code qui ne doit pas être interrompu (le soi-disant modèle de vue, je ne sais pas pourquoi « modèle » ; peut-être que je le traduis mal), et dans le code principal, sur une seule ligne, le fournisseur de modèles est appelé, auquel cette classe est passée en paramètre. Le fournisseur renvoie soit un objet de classe de modèle existant (après avoir tourné l'écran), ou crée un tel objet basé sur la classe passée, s'il n'existe pas encore, et le renvoie également (lorsque l'activité est lancée pour la première fois). Une activité peut toujours accéder aux fonctions et variables de cet objet.
Les trois composants sont combinés sous le nom officiel Android Architecture Components. Certes, il inclut également le composant LifeCycle, également situé dans la bibliothèque android.arch.lifecycle, mais il est utilisé en étroite collaboration avec LiveData, et je ne le soulignerais pas du tout. L’introduction de composants de ce type constitue un pas bienvenu dans la bonne direction pour Google. Je me plains depuis longtemps du nombre de classes différentes que je dois m'étendre et de toutes connecter les unes aux autres pour faire fonctionner quelque chose de plus que des exemples primitifs de manuels. Et finalement, les bons composants ont commencé à apparaître parmi les bibliothèques. J'espère que cette tendance se poursuivra.
Éditeur d'interface visuelle
Les innovations que j'ai découvertes dans la programmation des smartphones ne s'arrêtent pas là. Dès sa naissance, Android Studio a connu des moments très difficiles avec la stabilité et la prévisibilité de l'éditeur d'interface visuelle, même s'il était plus stable que dans Eclipse. Même en éditant directement le balisage XML de l'interface, il était très difficile de configurer tous ces Layouts et autres composants visuels pour qu'ils soient affichés aux bons endroits et sous la bonne forme.
Heureusement, dans Android Studio, à partir de la version 2.2, au lieu de construire une interface fantaisiste à travers des dispositions de disposition linéaire des éléments (Mise en page linéaire) il est proposé d'utiliser la nouvelle disposition forcée (ConstraintLayout). De plus, l'éditeur visuel a enfin été finalisé. Tout cela ensemble a eu un effet très positif. Désormais, il n'est plus si difficile de positionner correctement les éléments et ils se comportent de manière assez prévisible. Désormais, vous ne pouvez même plus toucher au balisage XML, mais effectuer toutes les actions dans l'éditeur visuel.
Le langage de programmation Kotlin, développé par la société JetBrains de Saint-Pétersbourg, est devenu le langage de développement officiel pour Android. Cela a été officiellement annoncé lors de la conférence Google I/O. L'équipe Kotlin est dirigée par Andrey Breslav, diplômé de l'Université ITMO. Pourquoi Kotlin est si apprécié du géant de l'informatique parmi de nombreux autres «jeunes» langages, comment et pourquoi de nouveaux langages de programmation apparaissent en général, lisez les commentaires des experts et la collection d'informations ITMO.NEWS.
Comment les langages de programmation sont développés
Selon diverses estimations, il existe déjà plus de deux mille langages de programmation différents dans le monde. Des mises à jour sont constamment publiées pour les anciennes langues et de nouvelles langues apparaissent également. Lorsque la syntaxe d'un langage ne change pas, mais devient seulement plus complexe et élargie, le développeur n'a besoin que d'un peu de pratique pour continuer à écrire dans son langage préféré. Parfois, la structure du langage lui-même change, puis le programmeur doit parfois réapprendre, s'adaptant au langage mis à jour. En règle générale, la transition vers une nouvelle structure se produit progressivement et par parties, c'est-à-dire que seulement 10 à 20 % du code du programme commence à être écrit dans le nouveau langage.
« Les programmeurs n’étaient pas entièrement satisfaits des langages C++ et Java, car ce sont des langages assez complexes et le premier est plus difficile que le second. Par conséquent, le langage Scala est apparu, apprécié par de nombreux programmeurs, mais il est également très complexe. La vaste expérience de JetBrains dans la création d'outils de développement de programmes pour divers langages de programmation lui a permis de créer en sept ans le langage Kotlin, entièrement compatible avec Java, mais plus simple et plus pratique que lui. Les langages de programmation sont en constante évolution ; plus personne ne se donne pour tâche de créer un langage universel. Malgré cela, chaque langue est plus efficace dans un certain domaine où elle est le plus souvent utilisée. Il existe même une direction dans la création de langages lorsqu'ils sont développés pour un domaine spécifique", a commenté le chef du Département de technologie de programmation de l'Université ITMO.
Aujourd’hui, certaines entreprises établissent même leurs propres évaluations linguistiques. Par exemple, la société TIOBE, spécialisée dans l'évaluation de la qualité des logiciels, calcule mensuellement l'indice de popularité de certaines langues depuis 2001. La liste générée contient 50 lignes, et pour qu'un langage de programmation soit inclus dans l'index, les développeurs doivent écrire une lettre correspondante à l'entreprise. Le calcul est basé sur les données de 25 moteurs de recherche Internet. Jusqu'à présent, Java est largement en tête du classement, suivi de C. Dans le même temps, les compilateurs de la liste soulignent qu'au cours de l'année écoulée, les deux langages de programmation sont devenus moins populaires, d'environ 6 %. Dans le même temps, TIOBE montre que le langage C était le langage n°1 jusqu'en 2002, et Java était à la 14ème place en 1997, mais cinq ans plus tard il a remplacé C en première position.
Vous pouvez donner une excellente conférence sur l'histoire du développement des langues : le conservateur des programmes académiques chez Yandex, directeur du centre des concours étudiants de la Faculté d'informatique de l'École supérieure d'économie explique comment les langues C , PHP, Ruby et Java sont apparus. Mikhaïl Gustokachine. Le conférencier souligne qu'un langage de programmation différent doit être choisi pour chaque tâche. Il dit par exemple que pour l'industrie militaire, il est préférable d'écrire dans le bon vieux Pascal, une langue née en 1970 ! Pourquoi? Parce que c'est plus fiable. Les applications métiers peuvent être écrites en Java car ce langage est également assez fiable, mais beaucoup plus simple à utiliser. L'expert souligne également qu'il est important de maintenir l'intérêt des programmeurs pour le langage en créant une communauté de développeurs qui écrivent dans ce langage. Si une infrastructure est créée autour d’une nouvelle langue et que les gens se rassemblent pour l’utiliser, alors seulement la langue deviendra populaire. D’ailleurs, les développeurs de Kotlin ont également adopté cette stratégie.
Un peu sur Kotlin
Le langage de programmation Kotlin a commencé à être développé par la société JetBrains de Saint-Pétersbourg en 2010. La sortie officielle du produit a eu lieu en 2016. La langue a reçu ce nom en l'honneur de l'île du golfe de Finlande sur laquelle se trouve Cronstadt. Coïncidence intéressante, le nom du langage populaire Java est également le nom d’une île d’Indonésie. La coïncidence n’est probablement pas fortuite. Comme indiqué dans le communiqué de presse, Kotlin devrait fonctionner partout où Java s'exécute, et l'un des objectifs était de créer un produit pouvant être utilisé dans des projets mixtes créés dans plusieurs langages.
Comme le notent les auteurs de Kotlin, le plus important pour eux était de créer un produit « pragmatique ». Cela signifie qu'ils ne se concentraient pas uniquement sur la correction des bogues et l'amélioration du produit, ce que n'importe quel programmeur ferait, mais qu'ils voulaient créer un outil utile.
« Les outils de développement, y compris les langages de programmation, évoluent constamment. Les langages diffèrent des autres outils en ce sens qu'ils sont assez difficiles à développer de manière évolutive. La nouvelle version du langage doit prendre en charge tous les programmes existants. Cela limite les possibilités de développement des langues existantes et crée le besoin d'en émerger de nouvelles. Le facteur qui détermine le succès d'un nouveau langage de programmation est avant tout la commodité pour les développeurs. En plus d'être concis et expressif, Kotlin est hautement compatible avec le code Java : vous pouvez utiliser toutes les bibliothèques existantes et même mélanger du code en deux langages dans un seul projet, il n'y a donc pas de difficultés de transition particulières", a commenté le chef de projet Kotlin chez JetBrains, diplômé de l'Université ITMO.
Pourquoi Google a adoré Kotlin
Sur le site officiel, les développeurs Android écrivent qu'ils ont observé la « montée » de Kotlin ces dernières années. Les Googleurs n'hésitent pas à décrire le langage comme impressionnant, concis, stimulant et agréable à utiliser. Il a augmenté la productivité : le code du programme qu'il contient est en moyenne 40 % plus court que dans d'autres langages, et Kotlin permet également d'éviter certaines erreurs dans le code. L'un des facteurs déterminants de la popularité de Kotlin chez Google était sa compatibilité avec Java, déjà utilisé dans le développement d'applications pour Android.
Désormais, lorsque les programmeurs commencent à créer une nouvelle application dans l'environnement de développement officiel d'Android Studio, ils peuvent immédiatement activer le plugin « Support Kotlin ». Vous pouvez également convertir des lignes de code déjà créées dans d'autres langages vers le langage Kotlin, insérer des blocs dans d'autres langages dans des lignes de code dans Kotlin. À l'avenir, davantage de bibliothèques et d'outils seront développés pour le langage, davantage de matériels de formation seront développés et il sera plus facile de trouver des solutions à d'éventuels problèmes.
« Le manque de garanties de prise en charge linguistique par Google a découragé de nombreux développeurs de passer à Kotlin. Même si tu aimes vraiment la langue,un programmeur pense toujours au risque qu'à un moment donné, ce langage cesse tout simplement de fonctionner. Il est désormais garanti que Kotlin ne cessera pas de fonctionner et nous nous attendons à ce que le nombre d'utilisateurs du langage augmente fortement. Il serait naturel de supposer que de nombreuses entreprises finiront par passer complètement à Kotlin, même si techniquement rien ne les y oblige, c'est simplement une question de préférence.“- a souligné Andrey Breslav.
Il a ajouté que Kotlin est développé très activement. L'équipe de développement travaille actuellement sur le système de build, la vitesse de compilation, l'amélioration des performances de l'IDE, l'ajout de nouvelles fonctionnalités à la boîte à outils, notamment celles liées à l'intégration dans Android Studio. Des travaux sont également en cours sur des projets multiplateformes (possibilité de compiler le même code pour plusieurs plateformes), et un certain nombre d'améliorations du langage sont en phase de conception.
Google a également souligné qu'il s'inspire du concept du langage Kotlin, selon lequel il a toujours été et restera gratuit pour les développeurs, c'est-à-dire un projet open source. Cela signifie que le langage n'est lié à aucune entreprise en particulier et que le code source est distribué sous une licence gratuite. Vous pouvez télécharger le produit. Pour soutenir le développement de Kotlin, Google et JetBrains vont créer un partenariat à but non lucratif. Aussi, dans le cadre de la « mission » d'Android, il est très important que les auteurs de Kotlin créent autour de leur produit une communauté de personnes impliquées professionnellement dans le développement de ce langage et aimant partager leur expérience. Par exemple, en novembre, la conférence Kotlin aura lieu aux États-Unis, et les développeurs pourront également recevoir quotidiennement des nouvelles et des conseils sur le produit logiciel et se rencontrer localement.
À propos, le projet Android Studio lui-même a été développé sur la base de l'environnement de développement logiciel IntelliJ IDEA, également créé par JetBrains. Mais malgré une coopération étroite, la société de Saint-Pétersbourg souligne qu'il n'est pas question de vendre JetBrains au géant informatique américain. Dans le même temps, Koltin ne sera pas conçu uniquement pour Android. L'objectif de l'entreprise est de rendre le langage de programmation adapté à différentes plateformes de développement.
Dernière mise à jour : 12/02/2017
Kotlin est un langage de programmation typé statiquement de JetBrains. Kotlin peut être utilisé pour créer des applications mobiles et Web.
Kotlin s'exécute sur la machine virtuelle Java (JVM) et est compilé en bytecode lors de la compilation. Autrement dit, comme dans le cas de Java, nous pouvons exécuter une application Kotlin partout où la JVM est installée. Bien qu'il soit également possible de compiler le code en JavaScript et de l'exécuter dans le navigateur. Et, en outre, vous pouvez compiler le code Kotlin en binaires natifs qui fonctionneront sans aucune machine virtuelle. Ainsi, la gamme de plates-formes pour lesquelles vous pouvez créer des applications dans Kotlin est extrêmement large : Windows, Linux, Mac OS, iOS, Android.
La première version du langage a été publiée le 15 février 2016. Bien que le développement de la langue elle-même soit réalisé depuis 2010. La version actuelle du langage est actuellement la version 1.2, publiée le 28 novembre 2017.
Kotlin a été influencé par de nombreux langages : Java, Scala, Groovy, C#, JavaScript, Swift et vous permet d'écrire des programmes dans des styles à la fois orientés objet et fonctionnels. Il a une syntaxe claire et compréhensible et est assez facile à apprendre.
Le domaine le plus populaire dans lequel Kotlin est utilisé est principalement le développement pour le système d’exploitation Android. De plus, il est si populaire que Google lors de la conférence Google I/O 2017 a déclaré Kotlin l'un des langages officiels pour le développement Android (avec Java et C++), et les outils pour travailler avec ce langage étaient inclus par défaut dans la fonctionnalité. de l'environnement de développement Android Strudio à partir de la version 3.0.
Vous pouvez télécharger le compilateur directement pour le langage Kotlin lui-même à l'adresse .
Les archives peuvent être consultées à l'adresse ci-dessus. Téléchargez et décompressez le dossier kotlinc de l'archive. Dans l'archive décompressée dans le dossier bin, nous pouvons trouver l'utilitaire kotlinc, qui servira à compiler :
Définissons maintenant un répertoire sur le disque dur pour les fichiers de code source. Par exemple, dans mon cas, le répertoire sera situé le long du chemin c:/kotlin. Créons un fichier texte dans ce répertoire et renommez-le app.kt. L'extension kt est une extension de fichiers en langage Kotlin.
Principal amusant (arguments : Array
Dans ce cas, nous définissons la fonction principale, qui représentera les actions effectuées par le programme. Pour définir une fonction, utilisez le mot-clé fun.
Cette fonction prend un paramètre args, qui représente un tableau de chaînes.
À l'intérieur de la fonction principale, une autre fonction est exécutée - println(), qui imprime un message sur la console.
Ouvrons la ligne de commande. Tout d’abord, utilisez la commande cd pour accéder au dossier où se trouve le fichier app.kt. Ensuite, pour compiler le programme, entrez la commande suivante :
C:\kotlin\bin\kotlinc app.kt -include-runtime -d app.jar
Dans ce cas, nous transmettons le fichier app.kt au compilateur c:\kotlin\bin\kotlinc pour compilation. (Pour éviter d'écrire le chemin complet vers le compilateur, vous pouvez ajouter le chemin à la variable PATH dans les variables d'environnement). Ensuite, à l'aide du paramètre -include-runtime, vous spécifiez que le fichier généré inclura l'environnement Kotlin. Et le paramètre -d spécifie comment s'appellera le fichier d'application créé, c'est-à-dire que dans ce cas ce sera app.jar .
Après avoir exécuté cette commande, le fichier app.jar sera créé. Maintenant, exécutons-le. Pour ce faire, entrez la commande
Java -jar app.jar
Dans ce cas, on suppose que le chemin d'accès au JDK installé sur l'ordinateur est spécifié dans la variable PATH des variables d'environnement. Sinon, au lieu de « Java », vous devrez écrire le chemin complet vers l'utilitaire Java.
Par conséquent, lorsque nous exécuterons le fichier, nous verrons la ligne « Hello Kotlin » sur la console.
En 2010, un groupe de développeurs de la branche russe de JetBrains a entrepris de développer un langage plus pratique et plus sûr que Java, mais pas aussi complexe que Scala. Le nom de cette langue a été donné en l'honneur de l'île de Kotlin, située dans le golfe de Finlande (par analogie avec Java, qui porte également le nom de l'île).
Si vous regardez un aperçu moderne des langages de programmation les plus prometteurs, y compris, vous y trouverez certainement Kotlin. Quelle est l'essence de cette langue, pourquoi tout le monde l'aime tant, quelles perspectives a-t-elle - nous en reparlerons plus tard.
Syntaxe
L'idée de créer un langage aussi pratique pour les développeurs débutants que expérimentés s'exprime directement dans sa syntaxe. Comme tout analogue moderne, Kotlin est extrêmement concis, compact et compréhensible. Une énorme quantité de code qui devait auparavant être écrit en Java peut désormais être simplement ignorée. Un exemple simple : utiliser un point-virgule pour séparer les instructions n'est pas obligatoire - le compilateur comprend désormais tout tout seul si vous passez simplement à une nouvelle ligne. Lors de la déclaration de variables, dans de nombreux cas, il n'est pas nécessaire de spécifier le type - il sera déterminé automatiquement.
En même temps, il faut dire que Kotlin, en termes d'enregistrement, est revenu un peu au style Pascal - ici aussi, la clarté l'emporte sur la clarté des structures. Vous pouvez en savoir un peu plus à ce sujet dans ce court article. Il couvre uniquement les principes de base de la construction des langages Java et Kotlin, il sera donc compréhensible par absolument tout le monde.
Cependant, nous laisserons quand même un petit bout de code :
amusant principal (arguments : Array
val scope = "monde"
println("Bonjour, $scope !")
}
Une entrée extrêmement simple qui devrait être compréhensible pour toute personne ayant étudié la programmation à l’école ou à l’université pendant au moins un an.
Il est important de mentionner que Kotlin est entièrement compatible avec Java. C’est pourquoi, au début, il était considéré comme un simple sucre syntaxique, utilisé pour des tâches complexes où l’on voulait simplement gagner du temps et des efforts.
Avantages
De manière générale, tous les avantages par rapport à Java ont déjà été évoqués, nous allons donc les rassembler au même endroit :
Volume de codes. Ne pas utiliser de morceaux de code archaïques inutiles accélère le processus de développement et augmente la lisibilité ;
Sécurité. Les règles de création de code intégrées dans la syntaxe du langage vous permettent d'éviter les petites erreurs difficiles à suivre qui surviennent uniquement lors de l'exécution du programme ;
Compatibilité en Java. Ceci est pratique à la fois du point de vue de l'apprentissage d'un nouveau langage et du point de vue du transfert progressif de vos produits logiciels de Java vers Kotlin. Par exemple, c’est exactement ce qui s’est passé avec l’application Basecamp.
Défauts
En tant que langage développé sur la base de Java, Kotlin présente deux inconvénients évidents en comparaison : la vitesse et l'élaboration. Dans le premier cas, tout est clair : en travaillant sur JVM, il est difficile de battre Java en termes de performances. Le deuxième problème est un peu tiré par les cheveux pour une langue aussi jeune, car elle est en circulation officielle depuis un peu plus d'un an. Oui, il y a beaucoup moins d'outils et de bibliothèques ici qu'en Java. Mais d’une part, ce n’est pas encore critique et, d’autre part, dans le monde Java, la quantité ne s’est pas toujours traduite en qualité.
Kotlin, pour l'instant, s'acquitte de ses tâches principales, et la compatibilité totale avec Java permet de fermer les yeux sur ces lacunes.
Perspectives
Malgré le fait que le développement de Kotlin a commencé en 2010, la première version officielle n'a été publiée qu'en février 2016. Depuis lors, la demande pour le langage a augmenté rapidement et, dans le classement TIOBE, il est entré dans le TOP-50 en un an. , et le mois dernier, lors de la conférence Google I, /O a annoncé la prise en charge officielle de Kotlin dans le système de développement d'applications Android.
Compte tenu de la grande popularité d'IntelliJ IDEA parmi les développeurs et de l'orientation stratégique de l'entreprise sur Kotlin, nous pouvons affirmer avec certitude que dans 3 à 4 ans, nous le verrons parmi les concurrents à part entière de Java et Swift dans le domaine du développement mobile. De plus, si les créateurs du langage ne sont pas déçus de leur produit, Kotlin continuera sûrement à conquérir sérieusement d'autres horizons : web, IA, Internet des objets, big data, applications de bureau.
Si vous êtes sérieusement intéressé par cette langue, n'oubliez pas de jeter un œil à son site officiel (version russe) et de découvrir tous ses avantages grâce à votre expérience personnelle. Dépêchez-vous avant que cela ne se généralise.