Devoxx – Kotlin

Depuis quelques mois, Kotlin fait parler de lui. Rien de tel qu’une conférence comme Devoxx pour prendre la température de ce nouveau langage.

Lors de cette session, Andrey Breslav nous a expliqué d’abord les motivations qui ont poussé JetBrains à investir dans le développement de Kotlin :

• se détacher des limitations du langage Java dues à la compatibilité ascendante,
• avoir un outillage performant. Notamment, une intégration de qualité dans les IDE, un debugger et un compilateur au moins aussi rapide que celui de Java. Pour garantir cela, JetBrains développe en parallèle du langage et du compilateur, un plugin pour l’intégration dans leur IDE IntelliJ ainsi qu’un plugin simple pour Eclipse,
• avoir une syntaxe plus expressive.

Ensuite, il nous a expliqué les choix de design du langage :

• entièrement compatible avec java,
• code concis,
• statiquement typé.

Ces choix ont été fait de manière à limiter les erreurs à l’exécution de l’application.

Pour cela, ils ont implémenté différentes fonctionnalités.

Pour les plus classiques :

• Closure,
• Pattern matching,
• Inférence de type,
• Simplification des accesseurs sur les propriétés,
• Les Traits.

Et pour les plus innovantes :

• Extensions Function,
• Casting ‘intelligent’,
• Static null safety guarantees,
• Inline function,
• Reified Generics,
• Build infrastructure.

Andrey nous a montré ensuite un grand nombre d’exemples notamment :

• Hello world avec le parcours d’une itération :

  namespace demo
  
  fun main(args : Array<String>) {
    for (name in args)
      println("Hello, $name!")
  }
  

• Extensions Function qui peut notamment permettre d’étendre les fonctions d’une classe. Ici, on ajoute la fonction plusAssign que l’on peut appeler par + ou += à StringBuilder :

  namespace demo
  
  fun main(args : Array<String>) {
    val names = new StringBuilder()
  
    for (i in args.indices) {
      names += args[i]
      if(i+1 < args.size) {
        names += ","
      }
    }
    println("Hello, $name!")
  }
  
  fun StringBuilder.plusAssign(s : String) {
    this.append(s)
  }
  

• Smart Cast pour ne pas caster l’objet si le type est déjà testé. Il peut être aussi utilisé dans un pattern matching comme dans l’exemple suivant :

  namespace demo
  
  fun foo(obj : Any?) {
    if(obj is String) {
      obj.substring(2)
    }
    when (obj) {
      is String => obj[0]
      is Int => obj + 1
      !is Boolean => null
      else => ...
    }
  }
  

• Le pattern matching accepte des expressions ou un ensemble de valeurs :

  fun bar(x : Int) {
    when (x) {
      0 => "Zero"
      1, 2, 3 => "1, 2 or 3"
      x + 1 => "Really strange"
      in 10...100 => "In range"
      !in 100...1000 => "Out of range"
    }
  }
  

Cerise sur le gâteau, Andrey nous a montré le compilateur et le debuggeur sous IntelliJ parfaitement fonctionnels.

Cette session était surtout participative avec pas mal de questions dans la salle. À chaque fois, Andrey répondait à ces dernières de manière pertinente et nous avons constaté que l’équipe JetBrains a bien réfléchi pour faire un langage simple. Kotlin possède une syntaxe proche de celle de Java et de Scala, tout en les allégeant.

Kotlin est encore en phase de développement et les discussions sont encore vives sur les choix de conception du langage. Pour preuve, la page de Kotlin contient énormément de commentaires sur les améliorations ou évolutions à lui apporter. Un langage de plus à surveiller de près.