[En Deux Mots] Ne faites pas de longues ruptures

Même si ce conseil paraît évident, j'ai fait cette erreur de ne pas le suivre. J'ai pris une longue rupture qui a atteint les 3 ans, durant lesquelles, je n'ai pas réalisé des projets complets. Mon travail de développement se limitait à ce que j'avais besoin pour assurer les Travaux Pratiques en Algorithmique (pour les étudiants en première année Mathématique et Informatique - MI). Deux ans en Pascal et une dernière année en C.
La cause principale de ce désastre était mes débuts en doctorat. entamer un nouveau domaine n'est pas toujours une chose facile, surtout s'il s'agit d'un domaine loin de l'informatique. Je me trouvais étudier les livres de psychologie, psychopédagogie, psychologie du développement, théorie de l'action et les théories des émotions.

Sloman, A. (2004, March). What are emotion theories about. In Invited talk at cross-disciplinary workshop on Architectures for Modeling Emotion at the AAAI Spring Symposium at Stanford University in March.

Les résultats de cette rupture étaient catastrophiques. Premièrement, mes productions étaient des codes dispersés qui visaient des exercices d'introduction à l'algorithmique, des exemples sur les boucles et quelques exercices très classiques comme la vérification d'une grille Sudoku ou bien trouver les nombres amis. Si mes participations sur les forums des débutants ont devenus plus détaillées et plus pédagogiques, mes participations sur les forums plus avancés commençaient à diminuer avant de s'arrêter complètement. Mon repository sur Source Forge a stagné complètement aussi.
Deuxièmement, je n'ai pas pu suivre du près les nouvelles approches révolutionnaires qui ont vu le jour durant ces années. Groovy était un langage des amateur, Docker était dans ces débuts et semblait avancé un peu doucement et l'école fonctionnelle semblait encore endormie. Après trois ans, Groovy n'est plus le langage pour les amateurs; il est devenu un langage et une plateforme très intéressante. Je ne pouvait même pas reconnaître des parties telles que Grail qui a changé complètement. Docker a aussi changé, maintenant, il est doté d'un écosystème complet et il est devenu la base d'autres plateformes telles que Fn. Cette dernière prouvait qu'une l'approche fonctionnelle est du retour et avec puissance; l'approche Objet sur laquelle je me basais complètement a commencé à montrer sa lourdeur sur le côté serveur.
Finalement, je ne reconnaissais plus ma plateforme préférée : Java (J2SE/J2EE). La J2EE 6 était une vrai révolution, les fichiers XML que j'ai tant utilisé ne sont plus nécessaires et ils sont généré automatiquement à partir des annotations. Les services web RESTful ont devenus plus simples et plus rapides à développer. Les annotations se multipliaient et les outils aussi. Java 8 et les expressions Lambda ont été introduites, je n'en savait rien sauf quelques articles très brefs que j'ai lus.
Comment je me suis réveillé ? Je préparé une formation Java pour des étudiants. C'était avant l'introduction du module Programmation Orientée Objet avec des Travaux Pratiques en Java. Tout simplement, j'ai trouvé du mal à écrire ma fonction main, c'était aussi grave. Durant les deux années suivantes, j'ai essayé de récupéré. Même si je me débrouille pas mal, je pense que tout ce la était facile à éviter si je ne me suis pas émergé complètement dans mon doctorat et mon enseignement.
Alors, Ne prenez jamais de longues vacances et ne faites jamais de grandes ruptures. Restez près de votre éditeurs et travaillez sur des projets, même les plus simples, d'une manière continue. Ne vous contentez pas des articles, installez les nouvelles versions et essayez les, ce n'est pas une perte du temps, c'est même un gain du temps.
(Pourquoi cet article ? Jetez un coup d’œil par ici)

En Deux Mots (une courte série)

Depuis environ 11 ans, j'ai entamé ma carrière en recherche. Le début était avec mon projet de fin d'études (pour en savoir plus, c'est par ici). Par la suite, j'ai décidé de continuer avec mes études supérieures; j'étais fasciné pour le monde universitaire et j'ai voulu l'intégrer. Durant les années qui suivaient (à partir de 2008), je passais d'un ingénieur qui se base sur ses outils conceptuels et techniques pour résoudre des problèmes (plus ou moins) pratiques à un jeune chercheur qui doit s'affronter à de nouvelles problématiques et à proposer de nouvelles propositions. La différence était énorme et le premier résultat était mon éloignement de l'aspect technique de l'informatique.
Après avoir intégré la famille universitaire, le problème continuait. Je travaillais sur la théorie pour ma thèse de doctorat et j'exploitais mes connaissances techniques de base qui étaient plus que suffisantes pour garantir mes responsabilités d'enseignement. Et puisque je n'avançais pas, alors je reculais.
Cette époque de 11 années était marquée, sur le plan professionnel, par une profonde sensation d'incertitude et d'hésitation. Les causes étaient multiples et le résultat était une grande influence négative sur ma concentration et sur mon rendement.
Si je fais un résumé de ma vie professionnel durant ces 11 années, je peux voir que j'ai commis des dizaines d'erreurs que je pouvais éviter facilement pour aller plus loin et pour accomplir beaucoup plus de ce que j'ai accompli. J'ai commis ces erreurs malgré les mises en garde et les avertissements des centaines d'auteurs.
Dans cette courte série, je vais essayer d'écrire à mon tour, pour moi et pour vous, à propos de ces erreurs à éviter. J'écris cette série pour moi parce que tout simplement je sens le besoin de le faire. Je l'écris aussi, pour vous, pour vous avertir et peut-être pour vous aider à éviter de tomber dans ces mêmes erreurs.
Le titre de la série est "En Deux Mots"; elle sera constituée de quelques articles courts (d'où l’appellation). Chaque article sera consacré à une (et une seule) erreur que j'ai faite. 

La prise d'otage sur les réseaux sociaux

Introduction

Les réseaux sociaux sont parmi les outils de communication les plus utilisés aujourd'hui. Combinés ensemble, et en comptant le nombre de personnes atteintes par chaque publication, les réseaux sociaux prennent, effectivement, le dessus sur les autres moyens tels que l'e-mail, le blogging et les forums.
Ces outils reposent sur un ensemble de notions issues de l'ingénierie sociale pour attirer les nouveaux utilisateurs et pour fidéliser les anciens. Ainsi, nous avons vu Facebook se classer comme le site le plus visité au monde pour plusieurs mois (avant de perdre cette position face à Google qui a repris son ancien classement).
Ces notions ont toujours été utilisées dans le marketing et par les différents groupes et organisations pour attirer des clients, des membres, des volontaires ou même des victimes. Le virus "I love you" me vient à l'esprit comme l'une des premières tentatives qui a montré à quel point il est facile de convaincre les gens à prendre une action risquer en exploitant les notions sociales les plus basiques. C'est pourquoi l'étude des réseaux sociaux est un axe de recherche très actif et pour différentes disciplines.
Néanmoins, l'abus de ces règles peut mener à des comportements et des conséquences que les créateurs de ces systèmes n'ont jamais imaginés. Dans cet article, je vais essayer de présenter une observation qui devient de plus en plus fréquente sur les réseaux sociaux et de plus en plus exprimée par les "facebookeurs" dans les différents groupes. Une observation qui me fait l'impression que Facebook est devenu, en quelque sorte, un moyen de prise d'otage durant la communication sur ce réseau.

Les modes de communication

La communication à distance est l'un des ajouts les plus important des réseaux informatiques.  En effet, les deux moyens essentiels de communications connus jusqu'à la mise en oeuvre d'ARPANet étaient la poste (le "mail") et la téléphonie (fixe). Ces deux modes sont de deux natures différentes :
Le mail est un mode de communication lent. Mais, il permet à l'émetteur de prendre son temps pour préparer la lettre (écrites, documents, colliers, etc..) à envoyer. Il lui permet aussi de se libérer après l'envoie et de ne pas rester bloqué pendant l'attente d'une réponse. Ce mode de communication est dit "Asynchrone".
La téléphonie, de sa part, est rapide. Mais, un appel téléphonique nécessite la présence des deux parties impliquées dans la communication. L'émetteur doit envoyer son information dans un délai très court. Il est ensuite bloqué en attendant une réponse. C'est pourquoi tout le monde déteste sa mise en attente lorsqu'on appelle un Call Center. Ce mode de communication est dit "Synchrone".
Pour les deux modes, il ne faut pas oublier une réalité : les deux modes restent secondaires en comparaison à une communication en face-à-face. C'est à dire, une communication suivant l'un ou l'autre de ces modes sera facilement interrompue si l'un des deux parts est déconcentré par une communication en face-à-face avec une autre personne. Personne ne favorisera la lecture d'une lettre si une autre personne présente avec elle dans la même pièce s'engage dans une conversation avec elle. La même affirmation est vrai dans la plus part des cas pour un appel téléphonique.

La communication sur Facebook

Le moyen de communication direct sur Facebook est sa messagerie. Cette dernière se présente comme l'outil le plus utilisé et le plus orienté vers une communication de personne à personne. Les autres moyens visent d'attirer les utilisateurs pour s'engager à des activités sociales. Cela explique pourquoi facebook a lancé une application séparer (Facebook Messenger) et elle n'a pas fait la même chose avec l'espace Market (par exemple).
La messagerie de Facebook supporte les deux modes de communication :
Elle permet un dialogue en temps réel (Synchrone) : la notion d'utilisateur connecté et la réception des messages en temps réel avec une notification sonore et visuelle pour attirer l'attention de l'internaute sont la base de cette fonctionnalité.
Elle permet d'envoyer un message à un utilisateur déconnecté (Asynchrone) : l'envoie de message est possible même si le destinataire n'est pas connecté. Il peut trouver le message qui lui a été destiné lorsqu'il se connecte.

Les nouvelles contraintes

Néanmoins, nous commençons à avoir de nouveaux comportements négatifs sur ces réseaux sociaux. Une fois engagé dans une communication synchrone, il est pratiquement impossible de la laisser sauf en donnant une justification détaillée. Cela représente une mise de pression injustifiée et complètement superflue sur les utilisateurs de ces réseaux.

La mention Vue

La mention Vu indique  l'utilisateur que son destinataire a vu son message. Après avoir vu son impact, je pense que son ajout n'est pas innocent et ne se résume pas à son simple objectif. La signification sociale de ce simple message a passé de "votre destinataire a vu votre message" à "votre destinataire ne veut pas vous répondre, il n'a pas le temps pour vous et il ose penser avoir d'autres choses plus importantes que vous". C'est, à la lettre, une explication donnée par un facebookeur de sa vision pour la mention Vu sans répondre au message.
Une complication qui est devenu une convention. Son risque est le fait qu'elle met encore plus de pression sur le destinataire. S'il ne répond pas, il risque d'offenser ou même de perdre son "ami". Ainsi, en exploitant la nature sociale de l'être humain, et en ajoutant une simple marque 'Vu', le réseau social arrive à "obliger" l'utilisateur à "répondre" et "ne pas quitter la conversation". Autrement, il se voit amené vers un conflit avec ses connaissances sur le réseau.

Temps de réponse

Un autre aspect de réponse largement exploité est le temps de réponse. Je désigne,  ici, par temps de réponse, la durée entre la mention "Vu" et l'envoie de la réponse. Bizarrement, le temps de réponse acceptable devient de plus en plus court. En effet, vous pouvez être "bloqué" si le temps de réponse dépasse les quelques minutes. C'est une autre tendance qui exerce encore plus de pression sur le facebookeur, non pas par le réseau lui même, mais par ses "amis".
Comme pour la mention Vu, cette mesure, qui ne devrait pas avoir une signification justifiée en parlant de la nature de communication Asynchrone, est devenue une mesure du respect et d'attachement du destinataire : "plus la durée est longue, moins il vous respecte et moins il est attaché à vous et plus il est prêt à vous perdre". Pour le mode de communication Asynchrone supposé supporté par la plate-forme, cette affirmation n'a aucun sens.

Conséquence

Ces deux nouvelles contraintes sont basées sur de simples observations. Il est possible de détecter d'autres contraintes qui s'imposent sur les utilisateurs des réseaux sociaux par leurs paires. Ces contraintes viennent pour représenter une pression supplémentaire et pour contrôler le comportement de l'utilisateur.
Pour les deux contraintes notées, il est claire que l'utilisateur sur Facebook doit prêter de plus en plus d'attention à ses discussions sur Messenger. Il doit aussi leur accorder une priorité plus élevée de celle accorder à sa vie réelle, son existence même. Autrement, il risque de perdre ses "amis". Répondre même si vous ne le voulez pas ou bien devoir répondre dans un délai record de quelques minutes veux dire que vous n'êtes plus libre et que vous n'êtes plus dans une communication saine. En effet, vous perdez l'avantage de la communication asynchrone qui vous autorise à avoir votre temps pour répondre et vous perdez l'avantage de la communication synchrone qui est caractérisée par sa rapidité et la facilité de sa terminaison. Vous êtes bloqué dans une communication textuelle, de longue durée, illimitée (ou presque) et obligeante.

Nouvelle pratique ?

Malheureusement, les solutions qui prennent de plus en plus de place entre les facebookeurs ne sont pas dans le bon sens. Il s'agit de quelques solutions pour dévier le problème et non pas pour corriger ces faux jugements donnés à des fonctionnalités basiques sur un système de discussion d'un réseau social. Je vais citer une pratique qui m'a tellement surpris qu'elle m'a poussé à écrire cet article.
Pour éviter l'apparition de la mention "Vu" sur un message ou une discussion, le facebookeur charge la discussion en lançant l'application, ensuite, il désactive sa connexion Internet (que ce soit en Connexion de Données ou Wi-Fi), il visualise la discussion et ferme l'application. Il réactive ensuite la connexion et lance à nouveau l'application de messagerie.
Vous allez penser que c'est pénible. Je suis parfaitement d'accord avec vous. C'est de l'effort et du temps perdus sans une justification valide. Cette pratique ne peut jamais être considérée comme une solution; elle consiste à remplacer l'obligation de répondre par l'obligation de passer par cette procédure pour lire le message sans laisser la mention "Vu".

La véritable solution

La véritable solution est la compréhension de quelques points essentiels :

• Un réseau social est pour communiquer à distance, cela ne doit, sous aucun prétexte, être plus important que la vie dans le monde réel.
• Un réseau social est pour vous laisser en contact avec vos amis. Si l'un d'eux vous fixe des règles ou essaie de vous contrôler par des convention débiles, il ne mérite pas d'être votre ami.
• Communiquer est une action volontaire pour passer un message entre deux personnes. Sauf état de guerre ou une situation d'urgence (question de vie ou de mort), l'activité de communication ne doit pas imposer des pressions ou des obligations; c'est contre sa nature.
• Si une personne lit votre message et n'a répondu, c'est qu'il ne peut pas ou même ne veut pas répondre. Aucune signification injustifiée ne doit être donnée à cette action de ne pas répondre. Vous n'avez pas le droit d'obliger les autres à prendre telle ou telle action. En gardant ce droit aux autres, vous le garderez pour vous-même aussi. 

Conclusion

A la fin, j'ai essayé de mettre le doigt sur des pratiques et des idées qui commencent à devenir une source de pression et de frustration sur les réseaux sociaux. Ces idées obligent les facebookeurs à prendre des actions même contre leur volonté. Elles donnent, aussi, le droit à des gens de juger d'une manière absolue les autres gens en se basant sur une action ou deux, sans justification, ni prise en compte du contexte et des conditions par lesquelles ils passent. Ces éléments détruisent les fondements d'une communication saine qui est supposée être l'objectif même d'un réseau social.
Il est évident qu'une analyse plus profonde peut révéler d'autres phénomènes et d'autres exploitations immorales des notions de l'ingénierie sociale. Est-il temps de commencer à enseigner ces pratiques à nos enfants ?

LazySloth : un outil pour générer rapidement des JavaBeans

Dans un article précédent (ici), j'ai encouragé l'idée de développer et de construire sa propre boite à outils pour réaliser des tâches répétitives ou ennuyeuses, même, si l'outil en question ne sera pas utilisé par d'autres personnes. L'outil peut être un script, un programme ou un (mini) (micro) logiciel qui fait une seule chose.

Le fait qu'il ne sera pas utilisé par d'autres personnes possède un côté positif. Il n'est plus nécessaire de bien documenter le code, respecter les modèles sophistiqués ou utiliser la dernière technologie. Il n'est plus nécessaire de contrôler toutes les données ou bien de corriger tous les bugs. C'est votre propre outil et vous connaissez ses points faibles.

Dans cet article, je veux présenter l'un de mes outils préférés : LazySloth. Comme son nom l'indique, je l'ai créé parce que je suis un peu "fainéant". Vu que je travaille souvent sur des diagrammes de classes ou bien des diagrammes Entité/Association, cet outil me permet de traduire rapidement ce diagramme vers des classes Java (JavaBeans) et des scripts SQL pour créer les tables adéquates.

L'idée est de faire le tout en une seule commande dans la ligne de commande. Cette commande est constituée de trois partie :

1. Qu'est ce qu'on veut générer :
    a. -java : pour générer des classes Java seulement.
    b. -sql : pour générer des script SQL seulement.
    c. -both : pour générer les classes Java et les scripts SQL.

2. Le nom de la classe ou de l'entité qu'on veut traduire vers Java et SQL.

3. La liste des colonnes séparées par des espaces. La première lettre désigne le type de la colonne, elle ne sera pas prise comme partie de son nom. Les types des données supportés sont les types que j'utilise personnellement dans les différents exemples :
    a. i : pour Integer, pour stocker des entiers.
    b. n : pour Numeric, pour stocker les nombres réelles.
    c. d : pour Date, pour stocker des dates.
    d. s : pour String, pour stocker des chaînes de caractères. C'est le type désigné par défaut si l'outil n'arrive pas à déterminer un type à partir de la première lettre de la colonne.

Il est possible d'ajouter des contraintes après le nom de la colonne. Elles doivent être séparées par des ":" pour ne pas les confondre avec le nom de la colonne. Les contraintes supportées pour le moment :

1. pk : pour désigner la colonne comme clé primaire.
2. sN : (exemple s20) pour spécifier N (20 dans l'exemple) comme taille de la chaîne de caractères.
3. a : pour désigner la colonne comme AUTO_INCREMENT.

Exemples :

Si la commande ne donne pas toutes les informations nécessaires, l'aide de l'outil est affiché :

java -jar LazySloth.jar

Une commande très simple consiste à créer une classe qui contient le id, le nom et le prénom :

java -jar LazySloth.jar -both Exemple1 sid:pk snom:s100 sprenom:s100

Le code Java généré est :

public class Exemple1{

 String id;
 public void setId(String p){
  this.id = p;
 }
 public String getId(){
  return this.id;
 }

 String nom;
 public void setNom(String p){
  this.nom = p;
 }
 public String getNom(){
  return this.nom;
 }

 String prenom;
 public void setPrenom(String p){
  this.prenom = p;
 }
 public String getPrenom(){
  return this.prenom;
 }

}

Le code SQL généré est :

Create Table Exemple1(
 id Char(100) Primary Key,
 nom Char(100),
 prenom Char(100)
)

Comme un dernier exemple, cette commande teste les qutre types supprotés :

java -jar LazySloth.jar -both Exemple2 iid:pk snomprenom:s200 ddatenaissane nsolde

Le code Java généré est :

public class Exemple2{

 int id;
 public void setId(int p){
  this.id = p;
 }
 public int getId(){
  return this.id;
 }

 String nomprenom;
 public void setNomprenom(String p){
  this.nomprenom = p;
 }
 public String getNomprenom(){
  return this.nomprenom;
 }

 Date datenaissane;
 public void setDatenaissane(Date p){
  this.datenaissane = p;
 }
 public Date getDatenaissane(){
  return this.datenaissane;
 }

 double solde;
 public void setSolde(double p){
  this.solde = p;
 }
 public double getSolde(){
  return this.solde;
 }

}

Le code SQL généré est :

Create Table Exemple2(
 id Int Primary Key,
 nomprenom Char(200),
 datenaissane Date,
 solde Decimal(10, 2)
)

Le projet entier se résume en une seule classe Java qui peut être facilement modifiée pour ajouter de nouveaux types de données, de nouvelles contraintes ou pour exécuter d'autres commandes après la génération du code telles que la compilation des fichiers Java générés ou bien pour exécuter les scripts SQL créés.

Le projet se trouve à SourceForge, l'outil que j'ai toujours utilisé pour télécharger des projets OpenSource bien avant l'arrivée de GitHub. Vous pouvez le télécharger par ici.

Apprendre Java : les frameworks et les langages JVM

Apprendre le langage Java ne veut pas dire apprendre sa syntaxe ou ses structures de base. Autrement, tout développeur C et C++ peut se voir comme un développeur Java. Apprendre Java veut dire un peu plus que la syntaxe.

Premièrement, il faut apprendre l'API Java. L'API Java fournie avec la JDK est très puissante. La majorité des applications J2SE reposent seulement sur l'API par défaut. Elle peut être considérée comme un facteur clé du succès du langage Java. Parmi les packages les plus utilisés :

1. java.lang : le package importé par défaut et qui contient les classes essentielles pour écrire un programme Java (System, String, Class, Exception, Thread, etc..)
2. javax.swing : (après AWT) pour les interface graphiques.
3. javax.net : pour la programmation réseau.
4. java.nio : (après io) pour les flux entrée/sortie.
5. java.sql : pour interagir avec les Bases de Données relationnelles.

Ainsi, nous pouvons développer une application de gestion réparties, suivant l'approche Client/Serveur avec Client lourd, basée sur une Base de Données centralisée avec support de l'importation et l'exportation des données en utilisant la J2SE standard sans ajouter d'autres API sauf le driver du SGBDR utilisé (qui ne sera plus nécessaire s'il s'agit du Derby fourni avec la JDK).

Mais est-ce tout ? Non.

Deux autres éléments essentiels dans l'apprentissage de Java sont les framework et les langages JVM.

Premièrement, nous trouvons généralement les frameworks dans le cadre de développement des applications entreprises (n-tiers) sous J2EE. Ces framework ont trouvé de la popularité avec le retard remarquable qu'a fait la bibliothèque standard J2EE dans ce domaine. En effet, sans ce retard, les frameworks Spring et Struts n'auront pas gagné du terrain. Ainsi, à une époque donnée, apprendre la J2EE était synonyme de "apprendre une framework J2EE".

Aujourd'hui cette affirmation reste valide mais pas avec la même puissance. D'un côté, la J2EE devient de plus en plus à jour; elle arrive à cacher ses inconvénients et sa lourdeur qui limitent sa productivité (présentation Adam Bien). Elle arrive aussi à proposer ses propres frameworks disponibles par défaut; nous avons remarqué aussi la qualité améliorée de ces framework (Java Server Faces en ai un exemple). De l'autre côté, les différents frameworks continuent de progresser et gardent leur avance par rapport à la plate-forme J2EE part défaut. Les nouveaux besoins et les nouvelles approches favorisent ces frameworks et compliquent la tâche de la plate-forme par défaut.

Deuxièmement, nous devons reconnaître les langages JVM; des langages de programmation basés sur la machine virtuelle de Java. Ces langages sont, généralement, compatible directement avec Java et peuvent accéder à toutes les bibliothèques disponibles sans aucun effort supplémentaire. Ils compilent leur code vers Bytecode de Java et profite ainsi de sa portabilité.

Ces langages sont proposés pour plusieurs raisons :

1. Simplifier et moderniser le langage : Java est un langage puissant mais lourd. Quelques langages sont proposés pour le simplifier et le moderniser. Groovy et Kotlin sont des excellents exemples.
2. Pour répondre à un besoin spécifique : Java est un langage général qui permet de développer différents systèmes et pour différents domaines, néanmoins, avoir un langage spécialisé qui garde la puissance de Java reste une option intéressante. Tel est le cas avec des langages comme Scala (programmation formel), SARL (programmation basée Agents) et Processing (dessins et animations).
3. Pour faciliter l'apprentissage de la programmation et du langage Java : Java est strict et nécessite un respect rigoureux des notions Objets; la chose qui n'est pas facile pour les débutants en programmation. Ainsi, quelques langage JVM sont conçu pour être facile et simple et pour cacher la lourdeur du Java. Javascool en est un excellent exemple.

 

 

La plus part de ces langages offrent leurs propres APIs. Ces APIs représentent un enrichissement remarquable à exploiter et à être pris en considération par les développeurs Java. Nous prenons, comme, exemple les chaînes de caractères sous Groovy. Ces chaînes de caractères sont implantées en utilisant la classe GString, une extension puissante de la classe String de l'API J2SE par défaut. En l'utilisant, nous pouvons, à titre d'exemple, bénéficier de :

1. La déclaration d'une chaîne de caractère sur plusieurs lignes (comme les commentaires sur plusieurs lignes) en utilisant le délimiteur """.

def maChaine = """Bonjour chèrs internautes,
Cela est un exemple sur les chaîne de caractères sur plusieurs lignes.
Merci Groovy."""

println maChaine

2. Il est possible d'effectuer des substitutions de variables en utilisant le $ associé à leurs noms dans la chaîne de caractères.

def monPrenom = "Tarek"

println "Bonjour ${monPrenom}."

Certain de ces langages ont pu prendre la place du Java. Kotlin, par exemple, est devenu le langage de développement des applications Android, malgré, qu'à la base, il n'était pas conçu pour cet objectif.

Ainsi, apprendre Java veut dire apprendre sa syntaxe, son API par défaut (J2SE et J2EE) et apprendre , selon vos besoins et votre spécialité, la framework ou le langage JVM le plus adéquat. A titre d'exemple, pour enseigner en présentiel et à distance, je me trouve orienté vers les langages Groovy, Javascool et Processing. Les frameworks, dans mon contexte professionnel, ne trouve pas assez de place à part des démonstrations très limitées pour les étudiants en Master (université de Jijel).

Groovy pour l'enseignement intial de la programmation

Le choix d'un langage du départ pour l'enseignement de l'algorithmique est crucial pour l'apprenant. La première impression qu'il forme sur le module et la programmation de manière générale peut influencer ses performances durant l'apprentissage. Cette influence peut dépasser le module algorithmique pour affecter les autres modules qui dépend fortement de la programmation.

Le choix pris à l'université de Jijel, par exemple, est le langage Pascal. Ce choix est encore présent dans plusieurs autres universités. Ce choix est justifié par la similitude entre l'algorithmique et le langage Pascal et la nature pédagogique de ce dernier. En suivant une formation en français, l'étudiant peut vite obtenir un programme en Pascal par effectuer une traduction vers l'anglais.

Algorithme Exemple;
Var
    a, b, c : Entiers;
Debut
    Lire(a);
    Lire(b);
    c <- a + b;
    Ecrire(c);
Fin.

Program Exemple;
Var
    a, b, c : Integer;
Begin
    ReadLn(a, b);
    c := a + b;
    WriteLn(c);
End.

Néanmoins, la syntaxe de Pascal n'est pas retenue par d'autres langages. En effet, délimiter les blocs par "Begin" et "End" ne trouve pas d'autre utilité que dans le langage Delphi (que je considère comme Object Pascal, c'est à dire, Pascal). Apprendre un autre langage, tel que C, C++ et Java, nécessitera la reprise de la syntaxe et des mots clés à nouveau.

Nous avons tenté, durant une année universitaire, de commencer avec le langage C. Un choix qui peut être justifié par deux points essentiels :

1. Le langage C est parmi les langages les plus utilisés et les mieux classés au monde. A mon avis, il le restera tant que les noyaux des systèmes, les pilotes et la programmation niveau bas reposent sur le langage C.
2. La syntaxe du langage C est reprise par plusieurs autres langages. Si vous pouvez écrire la boucle "for" en C, alors vous pouvez l'écrire en C++, Java, C#, PHP, Perl, Ruby, Groovy et bien d'autres.

Le résultat était satisfaisant : les étudiants ont pu assimiler le langage vu qu'il n'ont pas connu un autre langage plus simple. C'est à peu près comme Linus Torvalds qui a commencer à développer en binaire pensant qu'il est le langage assembleur.

Néanmoins, l'effort fournis était bien supérieur. La tâche était fatigante à la fois pour les enseignant et les étudiants. Le passage n'était pas intuitif entre l'algorithmique et l'étudiant devait faire un effort supplémentaire et un temps additionnel, ainsi, les séances du TP devenaient de moins en moins productives, particulièrement lorsque nous abordions les pointeurs. Les messages d'erreur sont moins claires et plus difficiles à comprendre par les débutants. Sous Pascal, ce problème n'était pas posé vu qu'il s'arrête et affiche la première erreur rencontrée et ses messages sont plus compréhensibles. Pascal cache, aussi, l'étape de création des liens et le rassemblement des parties du code.

Ainsi, chaque option possède ses avantages et ses inconvénients. Heureusement, de nouveaux langages sont proposés chaque jour et la liste des options est devenue très riche.

A mon avis, le langage Java doit être le centre de la formation. Il partage quelques caractéristiques de simplicité avec Pascal et il reprend la syntaxe du langage C. Avec une API bien conçue et une convention du nommage très claire, il est possible à tout débutant de se lancer en Java et vite comprendre ses bases et qu'est ce qu'il faut faire. Il commence à trouver sa place dans l'enseignement de l'algorithmique dans plusieurs universités (Stanford, par exemple). A l'université de Jijel et à la région Est de l'Algérie, le programme de formation normalisé prévoit le module "Programmation Orientée Objet" qui repose entièrement sur le langage Java comme langage d'application. Les messages d'erreur sont très claires et les éditeurs disponibles facilitent leur repérage et leur correction (des éditeurs comme Eclipse et NetBeans vont jusqu'à la proposition de solution au développeur, ils signalent les erreurs pendant la saisie du programme et avant même d'entamer la compilation).

Malheureusement, ce choix n'est pas sans inconvénients. Le premier inconvénient, qui l'inconvénient majeur de Java, est l'obligation de respecter strictement les notions de la programmation Orientée Objet. C'est à dire que tout le code (toutes les fonctions) doivent faire partie d'une classe. Dans un contexte d'apprentissage, ce point peut être problématique pour l'étudiant parce qu'il écrit un code qu'il ne comprenne pas. En effet, il est très difficile d'expliquer la signification de "class" et de "static" si l'apprenant essaie d'apprendre le sens de "variable" et "bloc".

Le deuxième inconvénient est ce mélange entre type primitifs et classes. Les types de base "int", "long", "float", "double" et "boolean" (liste non-exhaustive) ne sont pas considérés comme des classes mais String est une classes. Cela peut créer une confusion qui dure, des fois, plusieurs semaines.

Pour remédier à ces inconvénients, Groovy peut être la solution. Groovy est un langage de la JVM (la machine virtuelle Java), c'est à dire, il compile son code vers un code Java qui repose sur la machine virtuelle pour son exécution. Il peut faire appel à des API Java comme il possède ses propres classes (compatibles avec Java) qui "corrige" les manque du langage Java et le rend plus "moderne" (si nous pouvons le dire).

Parmi les éléments du java, nous citons les deux suivantes :
1. Il n'est plus nécessaire de mettre tout le code dans une classe. Il est possible d'opter pour un code "script". Il est possible, aussi, d'utiliser la fonction "main()" tout cours (comme le font le C et le C++).

println "Hello World!"

2. Tous les types sont des Objets. Les types primitifs sont automatiquement enveloppé dans leurs "Wrapper"s. Ainsi, la déclaration d'un int implique la déclaration d'un Integer. Cela est fait en toute transparence.

Sous Groopy, les premiers exemples seront beaucoup plu faciles et nécessiteront mois d'explication. Il nous éviteront aussi cette "écrivez le code tel qu'il est, nous allons l'expliquer plus tard" sur la partie "class" et "public static void main()".

def a = 10;
println a.class

Groovy n'est pas le seul. Plusieurs autres langages JVM peuvent être utilisés comme un point de départ pour apprendre l'algorithmique avant de passer vers Java. D'ailleurs, des langages JVM sont conçus spécifiquement pour l'enseignement; Javascool en ai un exemple. Les comités pédagogiques doivent laisser les choix ouverts et profiter des différents langages disponibles.

Editeur des diagrammes Entité/Association en une soirée grace à Processing

La facilité de dessin et de gestion des évènement permet au développeur sous Processing de préparer rapidement des prototypes ou bien des outils dans un temps record. Cette capacité est très nécessaire lorsqu'il s'agit de prouver une idée ou bien pour préparer une démonstration rapide pour votre client.

Dans cet exemple, j'ai créé rapidement un éditeur des diagramme Entité/Association sous Processing dans environs 350 lignes de code. L'éditeur ne permet pas d'annuler, de déplacer de sélectionner les objets créés. Néanmoisn, il permet de :

1. Créer des entités en faisant un clique gauche :
1. L'entité est créée à l'endroit où le clique a eu lieu.
2. L'éditeur vous demande le nom de l'entité qui ne doit pas être vide.
3. Il vous demande, par la suite, une liste d'attributs, une à la fois. La création de la liste des attributs s'arrête lorsque la chaîne vide est entrée.
2. Créer des associations en faisant un clique droit :
1. L'association est créée à l'endroit où le clique a eu lieu.
2. L'éditeur vous demande le nom de l'association qui ne doit pas être vide.
3. Il vous demande, par la suite, une liste d'attributs, une à la fois. La création de la liste des attributs s'arrête lorsque la chaîne vide est entrée.
3. Pour créer un lien, il faut dessiner une ligne d'un objet à un autre objet de différente nature (d'une entité vers une association ou bien d'une association vers une entité). Les autres liens seront refusés (l'unique vérification dans le système).

Au stade actuel, le système ne fait pas d'autres vérifications, c'est à dire, il est possible de créer deux entités avec le même nom, d'avoir deux attributs identiques et de mettre ce que vous voulez comme cardinalité. Mais, comme j'ai déjà mentionné, il s'agit d'une démo pour Processing plus qu'un éditeur.

Dans ce projet, vous pouvez voir comment différencier les bouttons de la souris en toute simplicit. Dans la méthode "mousePressed()", il est nécessaire de vérifier est ce qu'il s'agit d'un clique droit pour insérer une association ou bien d'un clique gaucheoù il faut véirifier est ce qu'il est appliqué à l'intérieur d'un objet ce qui veut dire qu'il s'agit d'un lien ou bien s'il est à l'extérieur de tout objet pour insérer une nouvelle entité.

void mousePressed(){
  if(mouseButton == LEFT){
    int entite = verifierEntites(mouseX, mouseY);
    if(entite != -1){
      creationLien = true;
      entiteSource = true;
      source = entite;
    }else{
      int association = verifierAssociations(mouseX, mouseY);
      if(association != -1){
        creationLien = true;
        entiteSource = false;
        source = association;
      }else{
        lireEntite(mouseX, mouseY);
      }
    }
  }else{
    lireAssociation(mouseX, mouseY);
  }
}

La vérification que le clique est à l'intérieur d'un objet se fait par rapport aux coordonnés et mesures de ce dernier. Ainsi dans la classe Objet, on trouve la méthode "estDedans()" :

  public boolean estDedans(int cx, int cy){
    return cx > x && cx < x + getLargeur() && cy > y && cy < y + getHauteur();
  }

La méthode qui est supposée faire toutes les vérifications concerant les noms des entitées, des associations et des attributs ne fait en réalité que lire ces valeurs sans aucune vérification; elle nécessite un effort supplémentaire :

void lireEntite(int mx, int my){
  String nom = JOptionPane.showInputDialog(null, "Donnez le nom de l'entité");
  if(nom != null && !nom.equals("")){
    Entite e = new Entite(mx, my);
    String propriete;
    int i = 0;
    do{
      propriete = JOptionPane.showInputDialog(null, "Donnez les propriétés (vide pour terminer)");
      if(propriete != null && !propriete.equals("")){
        e.addAttribut(propriete);
        i++;
      }
    }while(propriete != null && !propriete.equals("") && i < NOMBRE_MAX_ENTITES);
    e.setNom(nom);
    entites[nbrEntites] = e;
    nbrEntites++;
  }
}

Vous pouvez télécharger le code par ici.