Scala, partie 1

Je profite d’un peu de temps entre 2 missions pour me former à Scala depuis quelques temps. J’ai vraiment beaucoup de plaisir à apprendre et à travailler avec ce nouveau langage. Proche de Java, il est pourtant bien différent, et vraiment intéressant comme nous allons le voir ensemble.

James Gosling, l’un des inventeurs de Java, a dit à propos de Scala la phrase suivante :

« If I were to pick a language to use today other than Java, it would be Scala »

Plus suprenant, James Strachan qui a initié le langage Groovy en 2004, a dit aussi à propos de Scala :

« I can honestly say if someone had shown me the Programming in Scala book by by Martin Odersky, Lex Spoon & Bill Venners back in 2003 I’d probably have never created Groovy. »

Le langage a été initié en 2003. Scala (pour Scalable Language) a été pensé pour la programmation multi-threads, avec un niveau de qualité assez impressionnant. J’aime ce langage car au final, ce sera toujours du bytecode dans une machine virtuelle Java.
C’est un langage orienté objet avec une teinte de programmation fonctionnelle. Créé en 2003 par Martin Odersky, Scala est supporté par l’EPFL (Ecole Polytechnique Fédérale de Lausanne). Typé statiquement, il propose par exemple une inférence de type très puissante, qui rend la programmation Java « old-school » dès lors que l’on débute en Scala.

Scala est concis
Le langage est très concis. Prenons par exemple un BVOJTP (Bon Vieil Objet Java Tout Pourri) et voyons ce que cela donne dans sa version Scala. Je prends par exemple un simple Bean « Person » avec quelques attributs.

La version Java

public class PersonInJava {
    private String firstName;
    private String lastName;
    private Date dateOfBirth;

    public PersonInJava(String firstName, String lastName, Date dateOfBirth) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.dateOfBirth = dateOfBirth;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public Date getDateOfBirth() {
        return dateOfBirth;
    }

    public void setDateOfBirth(Date dateOfBirth) {
        this.dateOfBirth = dateOfBirth;
    }
}

La version Scala :

class PersonInScala(val firstName: String, val lastName: String, val dateOfBirth: Date)

Et oui… par défaut il n’est pas nécessaire de déclarer les getters/setters, ni de constructeur par exemple.

Inférence de types
Scala est capable de deviner les types associés à des expressions automatiquement (voir la définition del’inférence de types). Cela permet de conserver un type fort en interne, tout en allégeant le code source.

var year: Int = 2010
var anotherYear = 2010

var helloBuddy = "Salut !"

var builder = new StringBuilder("Bonjour")

println(builder.getClass())

La première variable est définie comme étant de type Int. Remarquez ensuite que la variable anotherYear est définie sans spécifier de type. Scala infère le type en Int automatiquement grâce à la valeur que nous avons assignée à cette variable. Ce type est définitif, il s’agit bien d’un type statique.

Si par exemple j’essaye d’affecter une String un peu plus tard à ma variable anotherYear alors Scala me signale à la compilation qu’il y a un souci :

var anotherYear=2010
anotherYear="This is a String"

(je compile le code...)

!!!
discarding 

Pour revenir un peu plus haut, la variable helloBuddy est inférée en java.lang.String automatiquement, et la variable builder en StringBuilder. Dans la pratique, pour un développeur Java il n’y a pas grand chose à faire. Il reste possible de typer ses variables, mais cela ne devient plus indispensable. Enfin la vérification à la compilation nous épargne les soucis de transtypage à la Java et certainement quelques soucis comme avec un langage dynamique.

Programmation fonctionnelle
Je ne vous donnerai qu’un aperçu car c’est un sujet vaste. En Scala il est possible de créer des fonctions à l’intérieur de fonctions, de passer des méthodes en paramètres à d’autres méthodes, bref les fonctions en Scala sont des Objets à part entière. Nous retrouvons la notion de pointeur de fonctions en quelques sortes.

La programmation fonctionnelle sera présenté en Avril au Paris JUG, ainsi que Scala d’ailleurs. Cela vous donnera l’occasion de voir un peu ce que cela peut vous apporter en tant que vieux Java-iste.

Prenons un exemple tiré du livre « Programming Scala » écrit par V.Subramaniam. Ecrivez une fonction qui effectue la somme d’une suite de nombre sur une plage passée en argument. Voici la version Java :

public int sum(int number) {
  int result = 0;
  for(int i = 1; i < = number; i++) {
         result += i;
  }
  return result;
}

Comment feriez-vous si je vous demande maintenant de faire l'addition des nombres pairs uniquement ? En Java vous feriez une copie de cette méthode, pour en créer une nouvelle, avec votre algo. En Scala, il est possible de passer une méthode en paramètre. Nous allons donc extraire la logique de la sélection des valeurs, et la définir à l'extérieur.
Des fonctions qui prennent en paramètre d'autres fonctions sont appelées "higher-order function". En Scala vous pouvez créer des fonctions à l'intérieur d'autres fonctions, les passer en paramètre et les assigner à des références.

Voici une version en Scala pour itérer sur une plage de valeur. Pour chaque valeur nous allons appeler la fonction référencée par codeBlock qui retourne un Int.

def totalResultOverRange(number: Int, codeBlock: Int => Int) : Int = {
 var result = 0
 for (i < - 1 to number) {
     result += codeBlock(i)
  }
  result
}

Donc pour effectuer la somme de valeur, nous pourrons appeler la fonction en spécifiant une fonction d'addition très simple :

// Sum up to 10
println(totalResultOverRange(11, i => i))

Le premier argument, 11, est la limite supérieure de notre série. Le second argument est une fonction anonyme qui prend en argument un type et qui le retourne sans modification. Notez qu’ici nous ne précisons pas le type Int, il sera inféré par Scala au moment voulu en examinant la signature de la méthode totalResultOverRange.

Si je vous demande maintenant d’effectuer la somme des nombres pairs uniquement dans la série, voici comment nous écrirons en Scala cet appel:

println(totalResultOverRange(11, i => if (i % 2 == 0) i else 0))

Si le modulo 2 du compteur courant est égal à 0, alors nous retournons i pour l’additionner, sinon 0.

Il est bien entendu possible de définir des Closures. Ici nous définissons une variable closure qui sera un pointeur vers une méthode.

def loopThrough(number: Int)(closure: Int => Unit) {
  for (i < - 1 to number) {
     closure(i)
   }
}

Voici un exemple d'utilisation :

var result = 0
val addIt = { value:Int => result += value }

Dans ces quelques lignes ci-dessus je crée une variable « addIt » qui est un bout de code pour effectuer l’accumulation de deux valeurs. Notez que la variable result n’est pas définie dans ce bloc ni comme paramètre. En fait cette variable est branchée à la variable result en dehors du bloc de code. Je pense qu’un exemple sera plus parlant pour expliquer cette subtilité :

var result = 0
val addIt = { value:Int => result += value }

loopThrough(10) { addIt }
println("Total of values from 1 to 10 is " + result)

result = 0
loopThrough(5) { addIt }
println("Total of values from 1 to 5 is " + result)

// Execution
Total of values from 1 to 10 is 55
Total of values from 1 to 5 is 15

Comprenez qu’une Closure est un bloc de code qui s’exécute dans un contexte, tout en étant capable de modifier des variables externes. Lorsque j’appelle la méthode loopThrough() en spécifiant une closure, la variable result est vue comme une variable globale. Lorsque je remet à 0 la variable, la closure le « voit » aussi et débute à nouveau l’itération de 0. Il est possible aussi de n’utiliser que des variables locales pour ne pas avoir cet effet bien entendu. C’est la vraie notion de Closure, où les variables d’une portée plus importante sont vues localement au sein de la fonction.

Conclusion de cette première partie
Scala est donc un langage fortement typé, capable de faire de l’inférence de types, avec une manipulation des fonctions très puissante, et la possibilité d’utiliser des Closures.

En Scala, tout est objet. Un nombre comme « 2 » est un objet sur lequel il est possible d’appeler une fonction. Les fonctions sont des objets, que vous passez en paramètre, afin d’exécuter des traitements fonctionnels.

Nous verrons la prochaine fois les Traits et les Collections, puis nous parlerons de programmation concurrente avec les Actors.

Je vous recommande la lecture de « Programming Scala » écrit par V.Subramaniam. Ce livre a été pensé pour des développeurs Java qui souhaitent apprendre rapidement Scala.

Je pense qu’il ne faut que quelques semaines pour être opérationnel. Il y a le risque de faire du « Java-like » avec Scala, comme nous faisions du C à la place du C++. Mais je pense cependant que vu la maturité du langage, la quantité de documentations et de livres disponibles, nous pouvons éviter de tomber dans ce piège.

Alexandre Bertails a préparé la version Scala de mon article sur le XML et Groovy. Vous verrez différentes versions d’ici quelques jours, le temps de terminer les 2 autres articles sur Scala.

Bon, je pose le crayon deux secondes, j’ai besoin de toute votre attention. Eteignez Twitter, fermez Gmail, écoutez-moi : vous allez apprendre Scala. C’est un ordre. Si vous ne voulez pas être sur le côté de la route lorsque les petits jeunes roulant en Scala Bac+5 passerons à côté de vous, bougez-vous. Achetez un livre, prenez le temps de vous former à nouveau.

Etre bon en Spring, Hibernate, GWT c’est bien. Maintenant ce qui va faire la différence, ce sera la capacité à proposer sur le marché d’autres langages pour répondre aux clients. N’oubliez pas ce que j’ai dit au début : Scala c’est du bytecode qui tourne dans une JVM. Donc pas d’excuses, vous me ferez 2 séries d’abdos, et ensuite vous filez en formation Scala.

Non mais !

Articles similaires:

Scala, partie 2 Scala, case, Option, None et Some Présentation de Play! Scala au Scala User Group Soirée Scala au Paris JUG