Paris JUG "Scala"

Le Paris JUG d'avril a pour thème le langage de programmation Scala.
Il se tiendra le mardi 13 à partir de 19h30, dans les locaux de l'ISEP.

Au programme :

19h15 à 19h30 : Accueil
19h30 à 20h15 : Scala, par Sadek Drobi
20h20 à 20h35 : Surprise de Belgique
20h35 à 21h15 : Buffet
21h15 à 22h00: Scala par la Pratique, par Romain Maton et Nicolas Jozwiak

Si je parviens à trouver un accès internet, vous pourrez suivre la conférence en temps réel sur la Wave ci-dessous. Elle sera ouverte en écriture lors de la conférence, pour que vous puissiez poster vos commentaires et questions.

EDIT : Le mode "embedded" semble capricieux aujourd'hui, et certaines Waves ne s'affichent plus.
Je vous recommande donc de suivre la conférence depuis votre client web à cette adresse : wave #A9AMCKoIA

EDIT 2 : J'ai trouvé pourquoi les Waves intégrées ne fonctionnaient plus : ces farceurs de Google ont sournoisement changé l'API... J'ai réparé tout ça, vous devriez pouvoir les consulter à nouveau. Je ferai un billet sur toute cette affaire prochainement, pour expliquer la nouvelle manière d'intégrer les Waves.
Et comme d'habitude, les lecteurs ne possédant pas de compte Wave peuvent lire la transcription textuelle de la conférence, tout en bas de cet article.

Annonces

Conférence exceptionnelle !
Du 31 mai au 1 juin, grand séminaire au Chalet de la Porte Jaune (château de Vincennes).
Plein de conférences, d'ateliers pratiques, de rencontres... Des speakers connus viennent de toute la planète !
Prix : 220€ en early bird, 270€ plein tarif.

L'équipe du JUG s'agrandit : Claude Falguière les rejoint.
Elle assurera la liaison avec les JDuchess (@duchessfr sur Twitter, jduchess.org)

Première conférence : Scala et les Fonctions

Présentation animée par Sadek Drobi (@sadache), Architecture Editor sur InfoQ, architecte Java.

La conférence portera surtout sur les concepts de programmation fonctionnelle implémentés dans Scala, et l'amélioration que ce langage apporte dans le domaine de l'OOP. La conférence suivante reviendra sur la syntaxe du langage.

Qu'est-ce que la programmation fonctionnelle ?
C'est un système de programmation à base de fonctions. Mais qu'est-ce qu'une fonction ?

Les Types

Tout d'abord, parlons des types de données primitifs (ou presque) :

1 : Int
"Hello" : String
List(1,2,3) : List[Int] // C'est une liste de Int
Map("Paris"->75, "Nancy"->54) : Map[String,Int] // C'est une map qui associe des Int à des String

Quel est le type d'une fonction ?

Function[Int, Int] ou Int => Int

Par exemple :

val f:Function[Int,Int] = i=>i; // Une fonction qui renvoie l'Int qui lui est passé en paramètre.

A quoi sert une fonction ?

C'est un bon moyen de transférer du code d'un endroit à un autre du programme. Le type de la fonction est donc très important, puisque c'en est l'interface.

Par exemple :

def gimmeAFunc(f : Function[Int=>Int]) {
  println(f(1));
}
def main(args:Array[String]) {
  gimmeAFunc( i=>i+1 );
}

Quelques applications concrètes:

Appliquer un traitement sur les éléments d'une liste :

def map[A,B](list:List[A], f:Function[A,B]):List[B] {
  for (element <- list) yield f(A)
}
def main(args:Array[String]) {
  println(map(List(1,2,3), (i:Int)=>i+1))
}

Exemples

Un autre problème de Java : la possible nullité des objets passés en paramètre. Définissons une structure capable de gérer les nulls (note : ce concept existe déjà en Scala : c'est Option.)
Dans l'exemple suivant, la méthode map() reçoit un Maybe qui wrappe un objet potentiellement "null" (Nothing). Si l'objet passé en paramètre est un Nothing, on le renvoie tel quel, sinon on applique la fonction passée en paramètre et on renvoie le résultat.

abstract class Maybe[A] (a:A) { // Classe qui encapsule un objet de type A
  def map[A,B](f:Function[A,B]) : Maybe[B] = {
    this match {
      case Nothing() => Nothing()
      case Just(a) => Just( f(a) )
    }
  }
}
case class Nothing[A]() extends Maybe[A]
case class Just[A] (a:A) exrends Maybe[A]

Utilisation :

val something = Just("Something")
println( something.map(s=>s.toUpperCase()) )

Autre exemple :

case class Point(x:Int, y:Int)
def main(args:Array[String]) {
  // Liste de modifications apportées à un point
  val modifs : List[Function[Point,Point]]
    = List( p=>Point(p.x,p.y+1), p=>Point(p.x+1,p.y) )
 
  val initialPoint = Point(1,1)
  modifs.foldLeft(initialPoint) ( (p,mp)=>mp(p) )
}

Alors, pourquoi des fonctions ?

On pourrait faire presque pareil avec les pointeurs de fonctions en C++ ou les classes anonymes en Java ?
En fait, c'est beaucoup plus simple quand les fonctions sont des types à part entière (first-class functions).
On peut les définir facilement, les réutiliser, elles ne sont pas confinées dans une classe particulière.

On peut composer les fonctions aussi, pour les "emboîter" les unes derrière les autres de manière transitive (il faut bien sûr sur le type de sortie d'une fonction soit le même que le type d'entrée de la suivante).

Higher-Order Functions (HOF)

Ce sont des fonctions qui permettent de manipuler et d'appliquer des fonctions.
Ex :

List(1,2,3,4,5).filter(i => i>3)
List(1,2,3,4,5).exists(i => i>3)
List(1,2,3,4,5).reduceLeft( (a1,a2)=>a1+a2 )

Vers une meilleure orientation objet ?

Java n'est-il pas plutôt orienté classes ? Ce sont les classes qui sont importantes (méthodes statiques, singletons...).
Il est impossible de modifier, de spécialiser des instances particulières d'une classe. C'est possible en Groovy et en Scala.
Les classes sont là pour représenter l'état initial d'un objet.

Les instances peuvent ensuite être spécialisées, enrichies en fonction de leur contexte d'utilisation.
Il reste encore plein de choses à découvrir dans les langages fonctionnels : Monades, Functors, Monoid, DCI, Actors...

Il existe d'autres langages fonctionnels : Haskell, Clojure, Erlang, F#...

Seconde conférence : Scala overview

Nicolas Jozwiak (Xebia)
Romain Maton (Xebia)

Scala a été créé par Martin Odersky, professeur à lEcole Polytechnique de Lausanne.
Il a travaillé sur les Generics en Java, qui ont un succès mitigé à cause de la rétrocompatibilité.
Scala a débuté vers 2003 ; Martin a essayé d'y intégrer les meilleurs éléments de différents langages.
Actuellement, parmi les langages alternatifs (hors Groovy), c'est celui qui a la meilleure progression.

Scala est orienté objet, statiquement typé, et interopérable avec Java.
Il prône la non nullité, l'immutabilité, et les fonctions en tant qu'entités de premier ordre.

Quelques avantages de Scala :

Inférence de types :

val listStrings : Array[String] = new Array[String]
val listStrings = new Array[String]

Déclaration de fonctions (cf conf précédente)
Excellent support des collections :

list.filter( {x:Int => x%2==0} )

Support natif du XML

De l'objet au fonctionnel

Pour parcourir une liste et additionner ses nombres pairs, en java on peut :

parcourir la liste normalement
utiliser des Prédicats (cf Google Collections)

En Scala on utiliserait une fonction.

Le présentateur explique qu'il est plus simple de mettre en place le pattern Visiteur en Scala qu'en Java, grâce aux "case class".
Ce construct permet de faire du pattern matching sur des objets complexes, par exemple du switch sur le type d'une classe.

Les Acteurs

Un Acteur est un objet qui vit dans la JVM. Il a une queue de messages d'entrée, et une queue de sortie.
On peut lancer un thread par acteur, mais plus couramment on utilise un pool de threads réparti entre tous les acteurs.
Les acteurs peuvent dialoguer inter-JVMs.

En Java, on utilise de la synchronisation explicite pour accéder à une certaine donnée de manière concurrente.
En Scala, des informations immuables sont échangées par les Acteurs : il n'y a donc aucune contention sur une donnée particulière.

Déclaration d'un acteur :

val printActor = actor {
  loop {
    react {
      case _ => println (text)
    }
  }
}

Utilisation :

printActor ! "foo"
printActor ! "bar"

Les Traits

C'est une interface dans laquelle on peut définir des méthodes et variables abstraites mais aussi concrètes.

trait Driveable {
  def drive() : String
}

On peut ensuite appliquer ce trait à une instance, qui bénéficiera alors de la méthode déclarée dans le trait.

val myCar = new Car with Driveable
myCar.drive()

Outillage

Eclipse : coloration syntaxique, intégration avec Java (y compris les Traits), etc.
Par contre, plante très souvent, et le projet est difficile à mettre en place. Et pas de refactoring !

IntelliJ : très bonne gestion de l'inférence, complétion bien gérée, création d'un projet très facile.
Un peu lent à compiler par contre.
Le plugin est gratuit et disponible même pour IntelliJ Community Edition.

NetBeans : A éviter.

Frameworks

ScalaTest : utilise un DSL puissant pour exprimer les tests.
AKKA : "Actors++". Fournit un système de tolérance à la panne, simplification des acteurs de type remote, et surtout 3X plus rapide que les acteurs standards de Scala ! Il fournit aussi de nombreux plugins : Comet, Rest, Spring, Scheduling...
Lift : le framework web. Séparation du code HTML et du code Scala, mais des tags spécifiques.

Conclusion

Freins à l'adoption et inconvénients :

Peut devenir très complexe
Syntaxe déroutante
Peur de l'inconnu
Courbe d'apprentissage, surtout à cause de l'outillage.

Le futur : Scala 2.8

Simplifier et unifier l'API des collections
Améliorer le REPL (complétion...)
Paramètres nommés et valeurs par défaut
Nouvelles structures de contrôle (breakable...)
Rupture de la compatibilité avec la v.2.7

Sites :

Livre : Programming in Scala, de Martin Odersky