Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

  1. #21
    Membre habitué
    Ah oui comme dit plus haut Google cherche à se débarrasser des avocats de Oracle, mais moi je me pose des questions sur la puissance et les performances de kotlin. De plus je doute qu'il arrive à détrôner java vu les nombreuses domaines d'utilisation de ce dernier. Que peut encore Kotlin à part le dev mobile🤷🏻*♂🤷🏻*♂🤷🏻*♂? Java est quasiment le seul langage adapté à n'importe quel projet
    .


    On peut remplacer Java par Kotlin pour n'importe quel projet. Par exemple avec Spring https://kotlinlang.org/docs/tutorial...t-restful.html
    Certes les grosses entreprises vont probablement rester sur Java parce que va côute trop cher de migrer du code, mais pour des nouveaux projets c'est clairement intéressant.

    Donc c'est un début parce que bon Kotlin rien que pour le null safety c'est quand même pas mal https://kotlinlang.org/docs/referenc...ll-safety.html.

  2. #22
    Membre expert
    Citation Envoyé par sylflo Voir le message
    Donc c'est un début parce que bon Kotlin rien que pour le null safety c'est quand même pas mal https://kotlinlang.org/docs/referenc...ll-safety.html.
    Rust a également ça en réserve : https://doc.rust-lang.org/book/ch06-01-defining-an-enum.html#the-option-enum-and-its-advantages-over-null-values.

    L'idée est de renvoyer des résultats encapsulés dans une enumération pouvant prendre les valeurs Some ou None :

    Code Rust :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
     
    fn soustraction_uint(x: usize, y: usize) -> Option<usize> {
        if y > x {
            return None
        }
        else {
            return Some(x-y)
        }
    }
     
    fn main() {
        let x: usize = 5;
        let y: usize = 4;
        let x_moins_y: Option<usize> = soustraction_uint(x, y);
     
        match x_moins_y {
            Some(d) => println!("x - y = {} - {} = {}", x, y, d),    // Le code va ici.
            None => eprintln!("La différence entre {} et {} est négative donc signée.", x, y)
        }
     
        let x: usize = 5;
        let y: usize = 9;
        let x_moins_y: Option<usize> = soustraction_uint(x, y);
     
        match x_moins_y {
            Some(d) => println!("x - y = {} - {} = {}", x, y, d),
            None => eprintln!("La différence entre {} et {} est négative donc signée.", x, y)    // Le code va ici.
        }
     
        let d = x-y;    // Le programme va crasher ici parce que 5-9 n'est pas non signé.
        println!("x - y = {} - {} = {}", x, y, d);
    }


    L'idée est même travailler de tout le temps avec cette encapsulation :

    Code Rust :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
     
    fn soustraction_uint(x: Option<usize>, y: Option<usize>) -> Option<usize> {
        if let Some(x_val) = x {
            if let Some(y_val) = y {
                if x_val >= y_val {
                    return Some(x_val - y_val)
                }
                else {
                    return None    // Parce que la différence est négative.
                }
            }
            else {
                return None    // Parce que "y est null" (si tant est qu'on puisse parler de null en Rust).
            }
        }
        else {
            return None    // Parce que "x est null" (si tant est qu'on puisse parler de null en Rust).
        }
    }
     
    fn main() {
        let x: Option<usize>= Some(5);
        let y: Option<usize>= Some(4);
        let x_moins_y: Option<usize> = soustraction_uint(x, y);
     
        match x_moins_y {
            Some(d) => println!("x - y = {}", d),    // Le code va ici.
            None => eprintln!("La différence entre {} et {} est négative donc signée.", x, y)
        }
     
        let x: Option<usize>= Some(5);
        let y: Option<usize>= Some(9);
        let x_moins_y: Option<usize> = soustraction_uint(x, y);
     
        match x_moins_y {
            Some(d) => println!("x - y = {}", d),
            None => eprintln!("La différence entre {} et {} est négative donc signée.", x, y)    // Le code va ici.
        }
     
        match soustraction_uint(None, y) {
            Some(d) => println!("x - y = {}", d),
            None => eprintln!("L'un des deux termes de la soustraction est null.")    // Le code va ici.
        }
     
        match soustraction_uint(x, None) {
            Some(d) => println!("x - y = {}", d),
            None => eprintln!("L'un des deux termes de la soustraction est null.")    // Le code va ici.
        }
    }


    Rust va même encore plus loin avec une énumération Result pouvant également te permettre d'embarquer une erreur dans le résultat : https://doc.rust-lang.org/book/ch09-02-recoverable-errors-with-result.html :

    Code Rust :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
     
    fn soustraction_uint(x: Option<usize>, y: Option<usize>) -> Result<usize, &'static str> {
        if let Some(x_val) = x {
            if let Some(y_val) = y {
                if x_val >= y_val {
                    return Ok(x_val - y_val)
                }
                else {
                    return Err("Différence négative")
                }
            }
            else {
                return Err("Le second terme est null")
            }
        }
        else {
            return Err("Le premier terme est null")
        }
    }
     
    fn main() {
        let x: Option<usize>= Some(5);
        let y: Option<usize>= Some(4);
        let x_moins_y_res: Result<usize, &'static str> = soustraction_uint(x, y);
     
        match x_moins_y_res {
            Ok(d) => println!("x - y = {}", d),    // Le code va ici.
            Err(msg) => eprintln!("La soustraction n'a pas pu se faire : {}", msg)
        }
     
        // Récupération de la valeur
        let x_moins_y: Option<usize> = match soustraction_uint(x, y) {
            Ok(d) => Some(d),
            Err(msg) => None
        };
     
        match x_moins_y {
            Some(d) => println!("x - y = {}", d),    // Le code va ici.
            None => eprintln!("Différence null.")
        }
     
        let x: Option<usize>= Some(5);
        let y: Option<usize>= Some(9);
        let x_moins_y_res: Result<usize, &'static str> = soustraction_uint(x, y);
     
        match x_moins_y_res {
            Ok(d) => println!("x - y = {}", d),
            Err(msg) => eprintln!("La soustraction n'a pas pu se faire : {}", msg)    // Le code va ici.
        }
     
        match soustraction_uint(None, y) {
            Ok(d) => println!("x - y = {}", d),
            Err(msg) => eprintln!("La soustraction n'a pas pu se faire : {}", msg)    // Le code va ici.
        }
     
        match soustraction_uint(x, None) {
            Ok(d) => println!("x - y = {}", d),
            Err(msg) => eprintln!("La soustraction n'a pas pu se faire : {}", msg)    // Le code va ici.
        }
    }


    (oui les enum Rust sont boostées aux hormones par rapport à celles de C/C++, mais ceci est un autre débat)
    "Ils ne savaient pas que c'était impossible alors ils l'ont fait." Mark Twain

    Mon client Twitter Qt cross-platform Windows et Linux. (en cours de développement).

  3. #23
    Membre éclairé
    Citation Envoyé par yahiko Voir le message
    Bien sûr qu'il est utilisé en masse encore dans les entreprises (choix de la génération des libristes des années 90 qui ont vu les mises à jour devenir payantes récemment...). Mais je vois bon nombre de projets ou des réflexions de projets pour remplacer Java, pas l'inverse.
    En majorité dans les entreprises, désormais, on développe en Java sur de l'existant principalement, pas pour lancer un projet from scratch.

    No offence though.

    Heu il te faut quoi comme argument ? Voir plus de projets vieux de 15 ans en NodeJS par Java oh wait ça existait pas à l'époque nodeJS

    Faire une réflexion sur quelque chose qui existe pour voir s'il y a pas mieux c'est une démarche saine, le remplacer parce que y'a un truc plus à la mode en est une autre.
    Beaucoup de projet se sont plantés en remplaçant une technos par une autre (et parfois le remplaçant était Java, parfois c'était le remplacé), car c'est plus une question de compétences techniques et d'organisation du projet. Et parfois de pas de chance avec des projets basés sur des lib/framework abandonnés.

    Franchement mon principal problème (celui qui me fait perdre le plus de temps et de loin) en Java est le même dans tous les langage chez moi : organisation de projet et compétences réelles sur les technos employés.

    Le jour où ce ne sera plus ça et je pourrais clairement avoir mieux pour ce que je fais, j'étudierais la question.

  4. #24
    Membre éprouvé
    Je comprends mal les diverses réactions des membres qui expliquent que Kotlin ne remplacera pas Java parce que Java n'est pas utilisé que sous Android.
    Ben.... heu.... Kotlin non plus: Il peut générer soit du code natif, soit du Javascript, soit du bycode Java: Pour l'instant il est au moins aussi utilisé sur les applications serveur que sur Android.
    Donc, si, il a vocation à pouvoir remplacer Java partout.
    Et force est de constater que ce langage est bien plus rigoureux et efficace que Java, c'est un vrai avantage.

  5. #25
    Membre expert
    Citation Envoyé par ClaudeBg Voir le message
    Je comprends mal les diverses réactions des membres qui expliquent que Kotlin ne remplacera pas Java parce que Java n'est pas utilisé que sous Android.
    Ben.... heu.... Kotlin non plus: Il peut générer soit du code natif, soit du Javascript, soit du bycode Java: Pour l'instant il est au moins aussi utilisé sur les applications serveur que sur Android.
    Donc, si, il a vocation à pouvoir remplacer Java partout.
    Et force est de constater que ce langage est bien plus rigoureux et efficace que Java, c'est un vrai avantage.
    Kotlin est-il en train de réduire Java EE au néant ? Fin du débat.
    "Ils ne savaient pas que c'était impossible alors ils l'ont fait." Mark Twain

    Mon client Twitter Qt cross-platform Windows et Linux. (en cours de développement).

  6. #26
    Chroniqueur Actualités

    Google annonce que près de 60 % des applications Android du Top 1000 embarquent du code écrit en Kotlin
    Google annonce que près de 60 % des applications Android du Top 1000 embarquent du code écrit en Kotlin,
    et renouvelle ses engagements envers le langage

    En mai, lors de la première journée de l'édition 2019 de sa conférence Google I/O dédiée aux développeurs, l'éditeur a annoncé que le langage de programmation Kotlin était désormais son langage préféré pour les développements d'applications Android. « Le développement d’Android deviendra de plus en plus Kotlin-first », indiquait Google dans un billet de blog. « De nombreuses nouvelles API Jetpack et fonctionnalités seront d'abord proposées pour Kotlin. Si vous commencez un nouveau projet, vous devriez l’écrire en Kotlin », poursuivait l'éditeur, précisant que « le code écrit en Kotlin signifie souvent beaucoup moins de code pour vous - moins de code à taper, tester et maintenir ».

    Kotlin est un langage de programmation orienté objet et fonctionnel, avec un typage statique qui permet de compiler pour la machine virtuelle Java et JavaScript. Il est développé par une équipe de programmeurs chez JetBrains, l'éditeur d'IntelliJ IDEA, l'environnement de développement intégré pour Java et sur lequel est basé Android Studio, l’EDI officiel pour développer les applications Android.

    Le support officiel de Kotlin pour le développement Android a été annoncé à la conférence Google I/O 2017. Pour l’équipe Android de Google, cette décision de supporter Kotlin s’expliquait aisément. D’abord le support EDI pour Kotlin : Android Studio est basé sur IntelliJ IDEA de JetBrains et l'équipe JetBrains travaille depuis des années pour s'assurer que Kotlin fonctionne parfaitement avec IntelliJ IDEA. Google héritera donc de tout leur travail pour supporter Kotlin dans Android Studio. Mais au-delà de cet aspect, Kotlin présente bien d’autres avantages. D’après Google, « Kotlin est [un langage] expressif, concis, extensible, puissant et agréable à lire et écrire », et « il a des fonctionnalités de sécurité intéressantes en termes de nullabilité et d'immutabilité » qui s'alignent avec ses investissements pour rendre les applications sûres et performantes par défaut.

    Le plus important d’après Google, c’est que Kotlin est interopérable avec les langages officiels pour le développement Android (Java, C++) et le runtime Android. La firme a expliqué par exemple que Kotlin fonctionne avec le langage Java de manière transparente, de sorte qu'il est facile pour les développeurs qui aiment le langage Java de continuer à l'utiliser, mais aussi d'ajouter progressivement du code Kotlin et de tirer parti des bibliothèques Kotlin. En outre, l'adoption de Kotlin sur Android augmentait régulièrement au fil des années, et d’après Google, avec un enthousiasme croissant parmi les développeurs ; une des raisons pour lesquelles la société a voulu accueillir Kotlin en tant que langage officiel sur Android pour assurer à ces derniers un meilleur support de Kotlin. Ce qui a été fait à partir d'Android Studio 3.0.


    En l’espace de deux ans, le langage Kotlin a gagné en popularité dans le développement des applications pour Android. En 2017, il devenait le deuxième langage officiellement pris en charge par Google pour sa plateforme mobile. En mai dernier, Google l'a officiellement recommandé aux développeurs. Aujourd’hui, presque 60 % des applications du Top 1000 embarquent du code écrit en Kotlin d'après une annonce de Google qui indique que :

    « Lorsque nous avons annoncé que Kotlin était un langage pris en charge pour Android, il y avait énormément d'enthousiasme chez les développeurs. Depuis lors, le nombre de développeurs utilisant Kotlin a régulièrement augmenté. Aujourd'hui, nous sommes fiers de dire que près de 60% des 1 000 meilleures applications Android contiennent du code Kotlin, de plus en plus de développeurs Android introduisant du code plus sûr et plus concis en utilisant Kotlin ».

    En 2019, Google s'est concentré à faire de la programmation Kotlin sur Android une expérience transparente, avec des API modernes Kotlin-first sur la plateforme Android. Plus tôt cette année, Google a lancé une préversion pour les développeurs de Jetpack Compose, une boîte à outils d'interface utilisateur moderne pour Android conçue à l'aide d'un langage spécifique au domaine Kotlin (DSL). Google a également intégré des coroutines dans plusieurs des bibliothèques phares de Jetpack, notamment Room et Lifecycle. Enfin, Google a apporté des extensions Kotlin (KTX) à des bibliothèques Google encore plus importantes, notamment Firebase et Play Core.

    Du côté de l'outillage, Google a renforcé son engagement envers Kotlin dans Android Studio et le pipeline de build Android. Des mises à jour importantes de R8 (le réducteur de code pour Android) ont permis de détecter et de gérer les modèles de bytecode spécifiques à Kotlin. La prise en charge des scripts de build .kts Gradle dans Android Studio a été ajoutée, ainsi qu'une prise en charge améliorée de Kotlin dans Dagger. Google a travaillé en étroite collaboration avec l'équipe JetBrains pour optimiser la prise en charge du plugin Kotlin et rendre l'expérience d'édition de Kotlin fluide et rapide dans Android Studio.

    L'éditeur, qui a participé à la KotlinConf, a également des projets d'avenir pour Kotlin :

    « En 2020, le développement d'Android continuera d'être Kotlin-first. Nous avons écouté vos commentaires et continuerons de travailler en partenariat avec JetBrains pour améliorer votre expérience avec Kotlin.

    « Cela comprend la collaboration avec JetBrains pour améliorer le compilateur Kotlin au cours de la prochaine année. Nos équipes rendent le compilateur plus extensible avec un nouveau backend et accélèrent vos builds avec un frontend nettement plus rapide. Nous travaillons également avec plusieurs des plus grands processeurs d'annotation pour accélérer la compilation du code Kotlin. Vous pouvez également vous attendre à plus de mises à jour Kotlin pour Android, y compris plus de bibliothèques Jetpack qui utilisent des fonctionnalités Kotlin telles que les coroutines ».

    Source : Google

    Explorer des échantillons de Kotlin

    Et vous ?

    Développez-vous des applications Android ? Avec quel outil ? En quel langage ?
    L'adoption de Kotlin est-elle, selon vous, liée au litige opposant Google à Oracle au sujet des API Java ?
    Dans ce cas est-ce la bonne direction à prendre pour les développeurs que de chercher des alternatives à Java ou gagneraient-ils à attendre la fin du procès pour sauter le pas ?
    Si vous avez déjà développé en Kotlin que pensez-vous du langage, de sa syntaxe, de sa robustesse, de la courbe d'apprentissage ?

    Voir aussi :

    Rubrique Kotlin
    À quoi s'attendre dans Kotlin 1.4 qui sera publié l'année prochaine ? Le langage promet d'être encore plus rapide, performant et multiplateforme
    Entre Java et Kotlin, lequel de ces langages est le meilleur pour le développement d'applications Android ?
    Kotlin 1.3.60 est disponible ! Cette version s'accompagne d'améliorations d'outils pour le débogage et apporte une préversion de certaines fonctionnalités déjà implémentées de Kotlin 1.4
    Contribuez au club : Corrections, suggestions, critiques, ... : Contactez le service news et Rédigez des actualités

  7. #27
    Invité
    Invité(e)
    Développez-vous des applications Android ? Avec quel outil ? En quel langage ?
    Oui. Android Studio. Java, C, C++.

    L'adoption de Kotlin est-elle, selon vous, liée au litige opposant Google à Oracle au sujet des API Java ?
    Aucune idée, j'ai pas trop suivi au point d'être affirmatif.

    Dans ce cas est-ce la bonne direction à prendre pour les développeurs que de chercher des alternatives à Java ou gagneraient-ils à attendre la fin du procès pour sauter le pas ?
    Autant attendre la fin, continuer en java ne bloque rien.

    Si vous avez déjà développé en Kotlin que pensez-vous du langage, de sa syntaxe, de sa robustesse, de la courbe d'apprentissage ?
    J'ai pas dev en kotlin, j'ai surtout regardé. J'aime pas la syntaxe, c'est encore du plus haut niveau que java ce qui veut dire encore moins de marge de manœuvre.

  8. #28
    Rédacteur/Modérateur

    « le code écrit en Kotlin signifie souvent beaucoup moins de code pour vous - moins de code à taper, tester et maintenir »
    Ce n'est pas très compliqué de faire un langage plus concis que Java

    Sinon, je me réjouis que l'avènement inéluctable de Kotlin et de la mort prochaine de Java.
    Tutoriels et FAQ TypeScript

  9. #29
    Membre régulier
    C'est magnifique cette news, par contre les offres Kotlin en France ... Le jour où les clients/employeurs comprendront que Kotlin n'est pas un langage cantonné au dev Android est loin d'être arrivé..

  10. #30
    Membre à l'essai
    Un concurrent sérieux DART
    DART et FLUTTER constituent un concurrent sérieux développé par Google.
    Surtout avec l'ouverture à d'autres plateformes (Ios,Linux,Windows et Webapp)
    qu'en pensez vous ?

  11. #31
    Membre actif
    Citation Envoyé par Stéphane le calme Voir le message
    Développez-vous des applications Android ? Avec quel outil ? En quel langage ?
    Pour ma première application Android, n'ayant aucune expérience préliminaire dans le développement mobile je me suis dirigé naturellement vers le Kotlin sur Android Studio.

    Citation Envoyé par Stéphane le calme Voir le message
    L'adoption de Kotlin est-elle, selon vous, liée au litige opposant Google à Oracle au sujet des API Java ?
    Difficile à dire, mais quoi qu'il en soit Google avait besoin d'un langage plus abordable pour proposer un alter-ego au Swift. La tendance est clairement le passage vers Kotlin, la preuve en est la statistique dévoilée dans cette article.

    Citation Envoyé par Stéphane le calme Voir le message
    Dans ce cas est-ce la bonne direction à prendre pour les développeurs que de chercher des alternatives à Java ou gagneraient-ils à attendre la fin du procès pour sauter le pas ?
    Je n'ai pas d'expérience en développement Java pour Android, mais un développeur ne risque pas grand-chose à essayer Kotlin étant donné que les 2 sont interopérables. D'ailleurs dans mon projet j'emploie des classes Java développées par qqn d'autre et cela ne pose aucun problème.

    Citation Envoyé par Stéphane le calme Voir le message
    Si vous avez déjà développé en Kotlin que pensez-vous du langage, de sa syntaxe, de sa robustesse, de la courbe d'apprentissage ?
    Pour ma part je suis convaincu que Kotlin est un excellent langage facile à prendre en main pour qqn qui commence le développement Android.


    J'aimerais revenir sur le commentaire de Stérilux :
    Citation Envoyé par Stérilux Voir le message
    J'aime pas la syntaxe, c'est encore du plus haut niveau que java ce qui veut dire encore moins de marge de manœuvre.
    Peux-tu en dire plus ? Je ne vois pas en quoi Kotlin est plus haut niveau que Java, de plus à ma connaissance on peut faire en Kotlin tout ce qu'on peut faire en Java. Du moins jusqu'à aujourd'hui je n'ai jamais été limité à cause de Kotlin.