Des questions à poser aux anciens de votre promo

Je donne actuellement des cours au développement web à des élèves en BTS (SIO et SN), dans le cadre de formation continue (en GRETA). J’ai appris que mes élèves du BTS SIO allaient rencontrer d’anciens élèves du GRETA, et cela m’a rappelé la manière dont s’était passée une rencontre similaire, lorsque j’étais moi même étudiant en BTS, il y a environ 25 ans. Je me souviens que les étudiants que nous étions ne savaient pas trop quelles questions poser, et que du coup ces rencontres s’étaient révélées peu instructives.

Ne sachant pas trop comment mes étudiants allaient gérer cette rencontre avec des anciens du GRETA, je leur ai proposé une série de questions à adresser à leurs interlocuteurs, questions que voici :
  • avec quel langage travaille-t-il actuellement ? (PHP, Javascript, autre)
  • avec quel framework (jQuery, Angular, React, NodeJS, autre…)
  • avec quel poste de développement (Windows, Linux, si Linux, lequel ? Debian, Ubuntu, autre?)
  • travaille-t-il avec un gestionnaire de version, si oui lequel (Git, Subversion ?)
  • avec quel IDE (Netbeans, Eclipse, PHPStorm, autre?)
  • quelles sont les compétences qui lui ont fait défaut à son arrivée sur le marché du travail ?
  • les recruteurs lui ont-ils fait passer des tests ? Si oui, de quel type (QCM, autre) ? Etait-ce difficile ?
  • Quelles compétences sont attendues par les recruteurs actuellement, selon lui ?
  • sur quel type de projet travaille-t-il actuellement ? Application métier à usage interne de l’entreprise, ou application destinée à être visible sur le web ?
  • s’agit-il d’application web, d’application mobile, si c’est du mobile, s’agit-il d’une application native, ou hybride ?
  • s’il s’agit d’appli web, doit-il dans ses développements gérer des problèmes de compatibilité entre navigateurs ? Si oui, comment s’y prend-il ?
  • développe-t-il côté back (PHP,  NodeJS, autre..) ou côté front (Javascript, framework tel que jQuery, Angular 1 ou 2, ReactJS, etc…), ou les deux ?
  • dans quelle structure travaille-t-il (société de services, client final ?)
  • est-il indépendant, salarié, en CDD ou en CDI ? 
  • s’il est dans une société de services, travaille-t-il au siège de la société, ou est-il détaché chez un client de la société ?
  • travaille-t-il sur un projet au « forfait » ou est-il en mode « régie » ?
  • quelle est la taille de l’équipe dans laquelle il travaille ?
  • son équipe utilise-t-elle une méthodologie agile (Scrum, autre..) ? Si oui, demandez-lui de vous expliquer comment se déroule un « sprint »
  • s’il travaille en société de services, ou même chez un client final, quels sont les avantages selon lui de ce type de structure ? et les inconvénients ?
  • à quel niveau de salaire pouvez-vous prétendre, selon lui, en arrivant sur le marché du travail ?

Oui je sais, j’ai peut être exagéré, mais il vaut mieux avoir l’embarras du choix, que le choix de l’embarras, pas vrai ? En tout cas, cela m’a bien amusé de préparer cette série de questions. Zut, l’heure tourne et j’ai encore un cours à préparer… bon allez, j’y retourne !

 

De bons bouquins pour s’initier à la programmation

J’ai mis à profit la période estivale pour lire pas mal de bouquins, et j’ai découvert quelques pépites dont j’ai envie de vous parler aujourd’hui. Je ne parlerai pas ici des quelques bouquins que j’ai lus pour mes besoins professionnels (ça fera peut être l’objet d’un autre article), mais plutôt des bouquins destinés aux personnes – jeunes ou moins jeunes – qui souhaitent s’initier à la programmation. Oui je sais, c’est une vieille marotte chez moi (j’ai déjà parlé de ce sujet dans de précédents articles), mais en plus de mes activités de développeur, j’enseigne aussi la programmation (essentiellement à des adultes). Je considère que cela fait partie de mon travail d’étudier comment mes confrères abordent cette discipline particulière qu’est l’enseignement de la programmation, cela me permet de m’améliorer en tant que prof.

Je vais donc vous parler de 3 livres, un en français et deux en anglais.

Commençons par le livre en français :

« Apprendre à programmer en Python (pour jeunes débutants de 7 à 97 ans) », de Frédéric Laroche (publié aux éditions Ellipses en 2015).

Je dois dire que j’ai été séduit par certains aspects de ce livre, aux illustrations sympas (de Gilles Macagno), et qui fourmille d’anecdotes. L’auteur a souhaité privilégier un style de programmation procédurale (plutôt qu’objet) pour que les exemples restent accessibles au plus grand nombre. C’est un choix qui se tient, mais j’avoue que j’ai été décontenancé par le premier chapitre, destiné à planter les bases du langage Python. Je trouve que l’auteur va souvent trop vite, et je me disais en lisant ce chapitre qu’un lecteur complètement néophyte pourrait se retrouver assez vite largué. En revanche, une personne ayant déjà quelques bases de programmation, en Python ou sur un autre langage, devrait pouvoir s’en sortir. Attention, le reste du livre est carrément génial. Au travers de jeux connus et moins connus, l’auteur livre un beau travail de pédagogue et j’ai pris un grand plaisir à le lire. C’est vraiment un bouquin généreux et sympa, et malgré le chapitre d’intro que je trouve un peu bancal, je vous le recommande.

Un autre livre, qui m’a procuré un grand plaisir de lecture, c’est celui-ci :

« Get Programming with Javascript« , de John R. Larsen, aux éditions Manning. Il est paru cet été, et j’ai sauté sur l’ebook dès sa parution. Pour le coup, d’un point de vue pédagogique, c’est un sans faute. Je trouve la présentation des fondamentaux de Javascript très progressive et cette progression est très réfléchie. Chapitre après chapitre, l’auteur construit un jeu de rôle au sein d’une page web, et l’enrichit de nouvelles fonctionnalités tout en présentant de nouveaux concepts de programmation. J’ai vraiment pris un grand plaisir à le lire, et je me prends à rêver que ce livre soit traduit en français, pour qu’il puisse toucher un lectorat plus large chez nous.

Le troisième livre que j’ai bien apprécié, c’est celui de Syed Omar et Faruk Towaha, paru chez Packt en janvier 2016 :

« Javascript Projects for Kids »

Le livre propose tout d’abord une intro à Javascript qui est sympa, mais de construction assez classique. Vous y trouverez aussi une introduction à jQuery qui est intéressante, mais les différents projets présentés ensuite ne s’appuient pas nécessairement sur jQuery, ce qui n’est d’ailleurs pas dérangeant. Il faut souligner que les chapitres sont quasiment tous indépendants, et présentent des projets écrits dans des styles souvent très différents. En fait, ce livre c’est un peu « l’auberge espagnole » du Javascript, mais il est généreux, fourmille de bonnes idées et les projets présentés sont sympas à réaliser. Je donnerais une mention spéciale au chapitre 9.3 (Dissecting Hangman) dans lequel les auteurs ont utilisé un graphique SVG pour dessiner leur pendu, et AngularJS pour masquer ou faire apparaître les différentes parties du pendu en fonction des mauvaises réponses (via la directive Angular « ng-show »). J’avoue que je n’avais jamais envisagé jusqu’ici de combiner Angular avec du SVG, et je me mets l’idée « de côté » car je la trouve sacrément futée. Attention, ce livre ne fournit pas d’introduction à Angular, du coup si vous ne connaissez pas ce framework, vous aurez peut être du mal à comprendre le code présenté dans ce chapitre du « pendu », mais ça peut être aussi un bon moyen de découvrir Angular, après tout…

Voilà… trois livres très différents, mais tous passionnants, car tous écrits par des auteurs passionnés, j’espère qu’ils vous procureront autant de plaisir qu’ils m’en ont procuré.

A noter que j’ai découvert un autre bouquin chez Manning qui s’intitule « Hello AppInventor!« , de Paula Beer et Carl Simmons (livre paru en 2014).  Je ne l’ai pas encore lu, faute de temps, mas il est sur le haut de ma pile, j’espère que je vais réussi à le lire rapidement. Pour ceux qui ne connaissant pas, AppInventor est un projet initié par Google et maintenu par le MIT. Cette application reprend les principes de Scratch, mais elle est destinée à développer des applications pour les tablettes et smartphones Androïd. Ca a l’air vraiment cool.

Allez, bonne rentrée à tous !!  😉

 

Pour les followers : mon Tweet

 

 

A tribute to Mary Everest Boole

Dans les années 80, j’ai eu la chance d’avoir entre les mains quelques bons bouquins d’initiation à la programmation. Dans certains de ces bouquins je découvrais de temps à autre des algorithmes produisant des formes géométriques complexes et fascinantes. Ma passion pour l’image numérique et l’algorithmique remonte à cette époque là. Mais les bouquins évoqués précédemment étaient pauvres en information quant à l’origine de ces algorithmes.

Il m’aura fallu pas loin d’une trentaine d’années pour découvrir que les principes fondateurs de ces techniques graphiques – désignées sous le terme de « curve stitching » ou encore « string art » – ont été posés aux alentours de 1900-1906, par une mathématicienne britannique du nom de Mary Everest Boole. Oui, vous avez bien lu, « Boole », car elle était en fait l’épouse du célèbre mathématicien et logicien George Boole. Féministe engagée, passionnée par l’enseignement des mathématiques et des sciences en général, elle a mené des travaux précurseurs dans ce domaine, travaux qui n’ont probablement jamais été diffusés en France (de son vivant, et même après) et qui semblent être tombés dans l’oubli aujourd’hui.

Je m’amuse depuis quelques temps à exhumer certains de ces vieux algorithmes et à les tester avec l’API Canvas du HTML5. J’ai commencé ce travail d’abord en Javascript natif, mais depuis peu je poursuis cette recherche personnelle avec P5.js, qui m’offre plus de souplesse pour triturer ces algos et les images résultantes.

Je vous invite à vous connecter dans mon labo sur la page suivante: Curve Stitching. Vous pourrez tester ces algorithmes en live, et vous trouverez sur la page d’introduction quelques références bibliographiques intéressantes.

A bientôt 🙂

Apprendre comment apprendre

Comment apprend-on ? Comment notre cerveau fixe-t-il de manière durable les concepts, les idées, les techniques que nous étudions quand nous suivons un cours ? Que se passe-t-il justement quand une notion que nous pensions acquise se révèle finalement complètement floue, et nécessite d’être réétudiée ? Pourquoi l’étude de nouvelles notions semble si facile pour certains, et si difficile pour d’autres ? Comment lutter efficacement contre cette fichue procrastination… et c’est quoi au juste, la procrastination ?

Nous avons tous des idées plus ou moins préconçues sur la manière dont notre matière grise fonctionne, mais finalement nous ne savons pas grand chose de cette drôle de machine qui est aux commandes de notre corps, et de notre personnalité.

A l’heure où tant de ressources sont accessibles en ligne pour se former sur tout un tas de sujets, il est grand temps que nous nous intéressions de plus près à ce drôle de pilote qu’est le cerveau.

Heureusement, des avancées majeures ont été réalisées ces dernières années, dans la compréhension de notre cerveau, et des mécanismes en jeu durant l’apprentissage. Des chercheurs renommés prennent aujourd’hui la peine de communiquer, notamment via internet, sur l’état des recherches en cours, et nous aident à y voir plus clair dans toute cette matière grise (jeu de mot lourdingue, désolé :).

Si vous m’avez lu jusque là, c’est que le sujet vous intéresse, OK… alors voici une sélection de vidéos et de cours que je trouve passionnants.

Tout d’abord, parlons de la procrastination. Si vous êtes sujet à ce phénomène, sachez que vous n’êtes pas le seul, et il faut absolument que vous regardiez la conférence TED de Tim Urban « Inside the mind of a master procrastinator » (sous-titre disponible dans plusieurs langues, dont le français). Avec beaucoup de drôlerie et d’intelligence, Tim Urban dédramatise le sujet, et nous aide à comprendre comment se créent ces dérapages qui nous mettent la tête dans le sac, alors même que nous avons des échéances à tenir et pas de temps pour le superflu.

Si Tim Urban nous explique la procrastination, pour apprendre à lutter efficacement contre ce phénomène, rien de tel que le cours de deux experts en neuro-sciences, Barbara Oakley et Terry Sejnowski. Ce cours, accessible gratuitement sur coursera.com, s’étale sur 4 semaines. Il   s’intitule Learning how to learn. Passionnant de bout en bout, il nous présente les dernières avancées en ce qui concerne la compréhension que les chercheurs ont du fonctionnement du cerveau. Les deux chercheurs se sont attachés à nous expliquer les mécanismes en jeu lors des périodes d’apprentissage. Comment fixer durablement les idées, comment lutter contre la procrastination, quelles sont les méthodes d’étude inefficaces qu’il faut éviter ? Vous trouverez dans ce cours les réponses à ces questions, et à bien d’autres.

Peut être êtes-vous, comme moi, intéressés par les mécanismes d’apprentissage en jeu chez les enfants, et notamment chez les tous petits. Alors il faut que vous suiviez le blog de Nouhad Hamam. Ce dernier anime un blog, une newsletter et un meetup où il expose clairement de quelle manière on peut stimuler l’envie de découvrir et d’apprendre, chez les enfants. Pour suivre les travaux de Nouhad Hamam, le plus simple est de vous enregistrer sur son portail : Hach The Kids.

Concernant l’apprentissage, et en particulier les difficultés d’apprentissage, il faut bien comprendre qu’il n’y a pas de fatalité et qu’une pédagogie adaptée peut faire des miracles. Encore faut-il vouloir s’en donner les moyens, et donner aux enfants foi en leurs propres capacités. C’est cela que Carol Dweck nous conte lors d’une magnifique session TED de 2014 qu’elle avait intitulée : The power of believing that you can improve.

 

 

 

La transmission du savoir

Le magazine Télérama, dans son numéro de cette semaine (n° 3459, du 30 avril au 6 mai 2016), consacre un dossier spécial sur la transmission, dossier qui s’intitule « Savoirs, Valeurs, Langue, veut-on encore transmettre ? ».

Dans ce même dossier, une phrase du philosophe Bernard Stiegler m’a particulièrement interpellé :

« Un savoir n’est pas seulement une information, mais la transformation de celui qui sait par ce qu’il apprend. « 

Je trouve cette idée très forte, et surtout très juste. Je sais pour me l’être appliqué à moi même à plusieurs reprises, que le processus de formation (ou dans mon cas d’auto-formation) peut transformer profondément votre schéma de pensée. Je ne suis par exemple plus le même développeur qu’il y a 20 ans, ni le même développeur qu’il y a 10 ans. A chaque étape, l’étude d’un ou plusieurs langages de programmation (SQL, Ruby, PHP, Javascript, etc…) a profondément transformé ma manière de penser l’architecture des applications que j’avais à développer.

Deux processus s’entre-croisent ici, qui me passionnent vraiment : l’acquisition et la transmission du savoir.

L’acquisition du savoir est un processus de longue haleine, qui passe par des phases répétées et entremêlées d’étude théorique et de pratique. Une petite phrase attribuée aux Shadocks, vue aujourd’hui sur le portail de Google décrit assez bien une partie de ce processus d’apprentissage :

« En essayant continuellement on finit par réussir. Donc, plus ça rate, plus on a de chance que ça marche ».

Le processus d’apprentissage, c’est un peu ça, il faut essayer, se ramasser, réessayer, se ramasser encore, sans relâcher son effort, jusqu’à ce que « ça marche ». Car le cerveau est un incroyable rebelle, qui donne parfois l’impression de travailler contre l’apprenant.

En tant que formateur moi-même, notamment sur des langages informatiques (PHP, SQL, Javascript..), et occasionnellement (mais de plus en plus rarement) sur des disciplines artistiques, je sais d’expérience que certaines notions peuvent sembler évidentes à certains élèves, alors que d’autres vont être, au moins pour un temps en résistance. C’est alors au formateur de trouver les analogies, les accroches, les voies détournées qui vont permettre de dénouer les tensions, de faire sauter les blocages.

Je dois dire que chacune des formations que j’ai dispensées ces dernières années a été une expérience unique. Unique par le fait que chaque groupe d’élèves est différent, et qu’au sein de chaque groupe les apprenants ont des profils souvent très différents, avec des attentes elles aussi très différentes. C’est alors un véritable challenge que de trouver le dénominateur commun entre ces personnes, de trouver le vocabulaire et les concepts qui vont « faire mouche » et faire que chacun va « trouver son compte » et sortir satisfait de la formation. Ca marche le plus souvent, mais ce n’est jamais gagné d’avance, et c’est un bon exercice d’humilité.

Finalement, même si je ne m’en rends pas compte sur le moment, je sors chaque fois un peu transformé par ces sessions de formations. Les difficultés que je rencontre quelquefois dans la transmission de la connaissance m’obligent à chercher de nouvelles pistes, à revoir ma manière d’expliquer, à élaguer souvent, pour ne conserver que le message essentiel. Comme me l’a dit très justement un jour un développeur, en lisant un dossier technique trop détaillé  :

« trop d’information tue l’information ».

Beaucoup de formateurs, croyant le plus souvent bien faire, tombent dans le travers de vouloir donner trop d’informations. Malgré l’expérience, il m’arrive encore quelquefois de faire cette erreur. La difficulté pour le formateur, c’est de détecter à quel moment il atteint le seuil de saturation au delà duquel le cerveau des apprenants va littéralement disjoncter. Si ce seuil est atteint, les apprenants se retrouvent en stress, les cerveaux se mettent en résistance, et le formateur passe complètement à côté de ses objectifs. C’est un véritable challenge de savoir détecter ce seuil de saturation, particulièrement au sein de groupe d’élèves de niveau hétérogène.

Je réalise que cela faisait bien longtemps que je n’avais pas relevé la tête du guidon pour prendre le temps d’écrire un petit article. C’est marrant, ça fait du bien 🙂 Je pense que je reviendrai plus souvent. Et si j’essayais d’écrire un article par semaine, pour changer…

Bon alors, euh… à bientôt !! 🙂

 

Apprendre la programmation aux enfants (again…)

Eh oui, en cette rentrée de septembre ensoleillée, je reviens sur un sujet qui me tient particulièrement à coeur, à savoir : enseigner la programmation aux enfants.

Je me demandais notamment s’il existait dans la littérature contemporaine de bons bouquins susceptibles de permettre à des enfants ou à des adolescents de s’initier à la programmation. J’emploie le terme « contemporain » sciemment car dans les années 80, et même au début des années 90, on trouvait de bons livres d’initiation, s’appuyant sur les langages BASIC ou Pascal. Et c’est d’ailleurs avec des ouvrages de ce genre que je me suis formé à la programmation, comme beaucoup de développeurs de ma génération.

Mais aujourd’hui, les langages BASIC et Pascal ne sont plus d’actualité. On peut d’ailleurs le regretter, car il s’agissait de langages particulièrement bien adaptés à l’enseignement. Mais bon, c’est comme ça… Les langages qui ont le vent en poupe aujourd’hui, ce sont des langages comme PHP, Javascript, Python ou Ruby. Et ma foi, ils sont aussi très bien, à condition de savoir adapter l’apprentissage aux capacités des enfants que l’on souhaite initier.

Pour en revenir à mon sujet du jour, j’ai déniché 3 bons bouquins en anglais, chez le même éditeur (NoStarch.com), dont un a été traduit en français et est disponible chez Eyrolles (il s’agit de « Python for Kids« ).

Les 3 ouvrages en question sont les suivants :

J’ai commencé par lire le livre de Bryson Payne, après avoir assisté à l’un de ses webinars. J’ai apprécié les idées proposées dans son livre, notamment son utilisation de la « tortue », une petite librairie Python qui permet de tracer des graphiques très simplement, un peu à la manière d’une ardoise magique (vous savez ce jeu indémodable qui consiste à tracer des formes au moyen de 2 roulettes). Pour la petite histoire, cette « tortue » était à l’origine un des composants d’un langage de programmation de plus haut niveau, le LOGO (cf. Wikipédia pour plus d’infos sur ce sujet).

Ce qui m’a dérangé dans le livre de Bryson Payne, c’est qu’il va très vite (trop vite à mon goût) vers des exemples assez complexes, qui pourraient décourager le lecteur si sa connaissance du langage Python est trop superficielle. En revanche ses exemples sont assez emballants, et il y a beaucoup de bonnes idées à puiser dans ce livre. Comme son sous-titre l’indique, ce livre est destiné à aider des parents qui voudraient enseigner la programmation à leurs enfants. Mais pour tirer pleinement parti de ce livre, les parents ont intérêt à bien maîtriser le langage Python, sinon ils risquent d’être perdus face à certains raccourcis pris par l’auteur.

A l’inverse, le livre de Jason R. Briggs, Python for Kids (livre qui est disponible chez Eyrolles en français), démarre de manière plus progressive. La première partie de son livre est peut être plus rébarbative, du fait qu’il prend le temps de présenter les bases du langage Python (il manquerait peut être de temps en temps un exemple amusant pour casser la monotonie de l’ensemble). En revanche, dès que Jason R. Briggs s’attaque à l’utilisation de la tortue, il m’emballe vraiment car ses explications progressives sont très accessibles, et très pertinentes, et c’est un plaisir de le suivre. Un adulte pourra aider un enfant à piocher dans ce livre les éléments intéressants adaptés à son niveau de compréhension. Un adolescent pourra sans aucun doute se débrouiller seul avec ce livre, s’il se forme en autodidacte.

Voici un exemple de programme Python exploitant la fameuse tortue graphique, pour générer des formes géométriques amusantes (exemple emprunté au livre « Teach your kids to code »).

import turtle
t = turtle.Pen()
for x in range(100):
	t.circle(x)
	t.left(90)

Et voici une prise de cliché de l’environnement Python, avec l’image en cours de réalisation :

turtle_python_exemple

Ces deux livres (« Python for Kids » et « Teach your kids to code ») me semblent très complémentaires. Mais je recommanderais le premier pour les bases solides qu’il apporte au lecteur, et le second comme complément pour le réservoir d’idées amusantes qu’il propose.

Le livre « Javascript for Kids », de Nick Morgan, est lui aussi très emballant. Je suis en train de le lire, mais comme je manque de temps, je risque de mettre encore quelques semaines avant de le terminer. J’aime beaucoup son approche très progressive, ses exemples simples et pertinents, son effort aussi pour – dans certains cas – prendre du recul par rapport au programme à implémenter (en proposant par exemple un pseudo-code en langage naturel décrivant l’objectif à atteindre, avant de le coder réellement en Javascript). Bref c’est un livre qui mérite qu’on s’y attarde, et qui mériterait lui aussi d’être traduit en français (peut être que les éditions Eyrolles sont déjà sur le coup, en tout cas je le souhaite).

Une question vous taraude peut être à l’issue de cet article : « alors… Python ou Javascript ? »

Franchement, j’adore Javascript, mais il me semble que Python a quelques atouts dans sa manche pour l’enseignement de la programmation aux enfants. Avec en premier lieu un shell complet incluant un éditeur avec coloration syntaxique, une librairie graphique intégrée (tkinter) qui permet de générer des graphiques très simplement (animés ou non), une librairie « turtle » intégrée dans la version standard de Python pour jouer avec la tortue… Bref, tout est fait dans Python pour faciliter l’apprentissage.

Avec Javascript, c’est un peu plus compliqué. On peut jouer avec de différentes manières, et en premier lieu on peut commencer par l’utiliser dans la console de son navigateur préféré, mais dès que l’on souhaite développer des choses sophistiquées, il faut ajouter des connaissances sur le HTML, le DOM, l’API Canvas du HTML5 (pour la génération de graphiques), choisir un éditeur de code, etc… Bref, l’écosystème de Javascript est un peu hétéroclite, et du coup un peu plus complexe que celui de Python. Du coup, je recommanderais l’apprentissage de Javascript plutôt à des adolescents (peut être à partir de 12 ans), alors qu’avec Python, il me semble que l’on peut démarrer plus jeune, plus facilement (peut être à partir de 8 ans).

J’ajoute que ces 3 livres me semblent également très bien pour initier des adultes à la programmation.

Voilà, j’espère que ce petit article vous aura intéressé, et surtout qu’il vous donnera envie de découvrir ces livres, ces auteurs, et peut être d’initier des enfants à la programmation au travers de ces très bons langages que sont Python et Javascript.

Sur ces bonnes paroles, je vous souhaite une très bonne rentrée. 🙂

Coder les règles métier dans DB2 SQL

Je vais vous faire un aveu, j’ai pas mal hésité sur le titre de cet article. J’avais par exemple envisagé de le titrer ainsi : « You don’t know DB2 SQL ». Comme une sorte de clin d’oeil à l’un des mes auteurs préférés, Kyle Simpson, qui a écrit une série de bouquins fantastiques consacrés au langage Javascript. Mais je m’égare déjà, alors que le sujet du jour, c’est DB2 SQL, et c’est en particulier la publication de 2 nouveaux articles, que j’ai déposés ces jours ci sur XDocs400.com, et qui sont les suivants :

Ces 2 articles traitent de sujets très différents, mais ils ont en commun deux points essentiels :

  • il s’agit de requêtes SQL qui embarquent du code « métier »
  • dans les 2 cas, il s’agit, à partir d’informations transmises par la base de données et/ou un utilisateur, de générer des données qui n’existent pas telles quelles dans la base

En effet, la génération d’un tableau d’amortissement d’immobilisation est un processus très orienté « métier ». A partir de quelques données fournies en entrée telles que la valeur initiale du bien, le taux d’amortissement et la durée de l’amortissement, on va générer un tableau qui a des caractéristiques très précises (imposées par la législation), avec la contrainte supplémentaire que le jeu de données produit contient des lignes qui n’appartiennent  pas à la base de données, du fait qu’elles sont générées dynamiquement via une RCTE (Recursive Common Table Expression). Autre subtilité spécifique aux tableaux d’amortissements, et qui apporte tout son piment à l’exercice, il y a une donnée qui est  « glissante » d’une ligne sur la ligne suivante : vous l’aurez sans doute deviné, je fais référence à la VNC, ou « Valeur Nette Comptable », qui de « fin d’exercice » sur une ligne N du tableau, devient VNC de « début d’exercice » sur la ligne N+1.

Dans le cas de la détermination des périodes de vacance de biens en location, on n’a pas besoin de la récursivité, mais on devra quand même reconstituer des données ne figurant pas dans la base de données, puisque l’on souhaite identifier les périodes d’inoccupation de logements (ou d’autres biens) à partir des périodes d’occupation. Il faut donc faire « matcher » les lignes correspondant aux périodes d’occupation spécifiques à un logement. On veut en effet comparer la date de fin d’occupation d’un occupant N, avec la date de début d’occupation de l’occupant N+1. Cela nécessite de créer un lien « virtuel » entre les différentes périodes d’occupation d’un même logement, et ce lien virtuel va être généré par la clause « PARTITION BY », qui va nous servir à déclencher une rupture à chaque changement de logement. Cette notion de rupture que les développeurs RPG connaissent existe aussi en SQL DB2, mais elle est rarement employée par les développeurs SQL et c’est bien dommage.

Les techniques SQL que je présente dans ces deux articles sont quelque peu inhabituelles, elle provoquent souvent des réactions de surprise du genre :

  • « ah bon, on peut faire ça en SQL ? »

ou encore

  • « dis donc, ça donne un peu mal à la tête ton truc »

Il faut en effet un peu de temps et de pratique pour s’approprier ces techniques, mais une fois que vous les maîtrisez, c’est tout un univers de possibilités qui s’ouvre à vous. Et quand on a la chance de travailler avec une base de données aussi puissante que DB2 – base de données multi-plateformes, je crois utile de le rappeler – ce serait vraiment dommage de passer à côté de telles possibilités.

Apprendre la programmation aux enfants

Cela faisait déjà quelques mois, que le plus grand de mes 2 garçons (qui a 7 ans et demi), me demandait de lui apprendre à programmer des jeux sur ordinateur. J’ai eu tout de suite envie de répondre positivement à sa demande, mais en même temps j’étais hésitant quant à l’approche à adopter (je souhaitais l’initier en douceur, sans risquer de l’effrayer avec trop de code…).

Mon fils avait déjà été initié à Scratch par sa maîtresse, et nous avions aussi expérimenté cette solution ensemble à la maison. Scratch me semblait pas mal pour découvrir les premiers rudiments de la programmation, mais faute de temps, je n’avais pas réellement exploré toutes les possibilités de l’outil. Plus récemment, nous avions testé ensemble CodeCombat, un logiciel d’apprentissage en ligne destiné à s’initier à la programmation dans différents langages (nous avions testé cette solution avec l’apprentissage de Javascript). La solution me plaisait assez, et mon fils avait semblé « accrocher », mais après réflexion, son verdict fut sans appel : « c’est déjà tout fait, moi je veux créer mes propres jeux ».

Par ailleurs, j’avais parcouru plusieurs livres (en anglais) sur la programmation de jeux en Javascript (exploitant notamment l’API Canvas de la norme HTML5). Mais chacun de ces livres présentait différents moteurs Javascript de création de jeux, et je n’arrivais pas à me décider sur l’utilisation de l’un ou l’autre de ces moteurs pour initier un enfant de 7 ans à la programmation.

A la veille des congés scolaires de ce Noël 2014, je tombe sur un article publié par le magazine WebDesign (numéro 36) qui s’intitule : « Créer des jeux HTML5 ». En parcourant l’article, je me suis dit que le jeu proposé (un petit jeu de plateforme très classique), pourrait plaire à mon garçon.

Le jeu proposé dans l’article s’appuie sur le moteur de jeu Crafty.js, complété d’un moteur de génération d’effets physiques, Box2DWeb.js, pour le mouvement des personnages. Le code Javascript du jeu lui-même est relativement simple. J’y vais donc par étapes, montrant à mon garçon comment constituer une page HTML. En ajoutant progressivement différents éléments à la page (un titre, puis une balise « div » avec un peu de texte dedans), et en rafraîchissant périodiquement la page dans le navigateur, j’ai pu lui montrer les premiers rudiments d’un site internet. Puis j’ai ajouté les premiers éléments du code Javascript. Au fur et à mesure de l’avancement, je lui ai montré les erreurs que je faisais (signalées par la console du navigateur) et comment les corriger. Il ne semblait pas du tout s’ennuyer et me posait plein de questions.

Quand nous sommes arrivés à la phase de création des personnages, j’ai proposé à mon fils de les dessiner sur une feuille, ce qu’il a fait avec grand plaisir. J’ai ensuite scanné ses dessins, et il les a retravaillés sur le logiciel Gimp, en ajoutant de la couleur via le pinceau et le pot de peinture. Nous avons redimensionné les dessins, en les mettant aux dimensions requises pour le jeu et nous avons vu les personnages apparaître sur l’écran, les uns après les autres, au fur et à mesure de notre progression. J’ai ensuite montré à mon garçon le principe de la couleur de transparence (pour le contour des personnages), et il a vu immédiatement la différence de rendu sur l’écran.

C’est mon plus jeune fils, qui a 3 ans et demi, qui s’est attelé à la tâche de dessiner le fond d’écran du jeu. Il faut dire qu’il venait périodiquement voir où nous en étions, et il a finalement eu envie de participer lui aussi, à sa façon. Pour dessiner le fond d’écran, il a utilisé Pixia, un petit logiciel de dessin, plus convivial pour les enfants que Gimp, dont l’interface est un peu austère, il faut bien le reconnaître. Comme mon fils a beaucoup usé de la gomme, on voit plus le fond d’écran rose (par transparence) que les couleurs qu’il avait placées dans un premier temps. Mais le rendu final est finalement très sympa.

Le jeu fonctionne, même si, bien évidemment, il n’est pas complètement fini (les garçons ont repéré quelques petits bugs en jouant avec, mais rien de grave). On va donc le retravailler, l’améliorer, sans doute lui ajouter de nouveaux tableaux (il n’en contient qu’un pour l’instant). Vous trouverez la toute première version du jeu (conforme à l’article du magazine Webdesign, hormis le design des personnages et du décor) en cliquant sur ce lien. Je l’ai mis en ligne pour que mes enfants puissent le montrer à la famille et aux amis.

Je me suis régalé à créer ce premier jeu avec mes enfants. Cela m’a rappelé l’époque, fort lointaine, où je créais des jeux sur mon Commodore64, à partir de listings trouvés dans divers magazines d’informatique. Mais surtout cela m’a permis de vérifier que Javascript était un langage qui pouvait être tout à fait adapté à l’apprentissage de la programmation, pour de jeunes enfants. Bien évidemment, c’est moi qui ai saisi la majeure partie du code, mais en y allant par étapes, en expliquant ce que je faisais, et pourquoi je le faisais, j’ai vu dans le regard de mon grand garçon qu’il n’en perdait pas une miette. De plus, le moteur Crafty.js me semble une bonne solution pour le développement de jeux adaptés à de jeunes enfants, du coup je vais étudier plus avant sa documentation, qui me semble plutôt bien faite. Et je vais étudier aussi, pour comparaison, la documentation de Phaser, un autre moteur de jeu, qui semble également très puissant et très polyvalent. Je vous tiendrai au courant de mes découvertes, et des prochains développements réalisés avec mon grand garçon, qui semble avoir plein d’idées, suite à cette première expérience.

Sur ce, bonnes fêtes de fin d’année à tous, et à l’année prochaine !!!

Deux nouveaux dossiers sur XDocs400.com

En ce 1er septembre 2014, je viens de publier deux nouveaux articles sur le site XDocs400.com.

Dans le premier dossier, j’explique comment contrôler, via SQL, l’existence d’un objet IBMi. La technique est simple et consiste à écrire un petit programme CL (qui fait un CHKOBJ et renvoie en sortie un flag indiquant si l’objet existe ou pas). Ce programme CL est encapsulé dans une fonction SQL de type externe, et pour une plus grande souplesse d’utilisation, j’ai également écrit une petite fonction « full SQL » qui appelle la fonction externe. La fonction « full SQL accepte des paramètres de type VARCHAR, ce qui offre une plus grande souplesse d’utilisation (la fonction de type externe n’acceptant que des paramètres de taille fixe équivalents à ceux du programme CLP, son utilisation, notamment lors des tests, est plus compliquée).

Dans le second dossier, j’explique comment contrôler la validité des Jobd d’un serveur IBMi. Pour ce faire, je m’appuie sur un programme RPG encapsulant l’API QWDRJOBD. Ce programme avait été publié en 2006 par Robert Cozzi, et c’est une version partiellement réécrite en RPG Free que je propose dans ce dossier. En plus du programme RPG, il y a quelques fonctions SQL et programmes CL, mais je n’entre pas dans le détail ici, je vous laisse le soin de les découvrir en lisant le dossier sur XDocs400.com. A noter que dans ce second dossier, je fais appel à la fonction de contrôle présentée dans le premier dossier. Il est donc préférable d’avoir lu le premier dossier avant de lire le second.

Ces deux dossiers sont extraits d’un cours « SQL avancé pour développeurs IBMi » que je dispense dans le cadre de mon activité de consultant. Pour tout renseignement concernant ce cours, vous pouvez prendre contact avec moi via l’adresse mèl suivante : contact@six-axe.fr

Bonne lecture.
Grégory

Le Merge sous SQL DB2

Je viens de publier sur le site XDocs400.com un nouvel article que j’ai intitulé « Le MERGE sous SQL DB2« .

Cela faisait un moment que je voulais écrire un article concernant cette instruction SQL, apparue sur la V7R1 de DB2 for i, mais comme j’étais sur plusieurs dossiers « chauds », je ne trouvais tout simplement pas le temps de le faire. Enfin, je n’ai pas beaucoup de mérite à publier cet article maintenant, vu que ce n’est finalement qu’un extrait du cours « DB2 SQL avancé » sur lequel je planchais en fin d’année dernière.

Je tenais beaucoup à publier cet article, car le MERGE SQL est certainement une des instructions les plus intéressantes pour les développeurs d’applications de gestion, qui ont souvent à écrire des choses du genre : « si cette donnée existe dans la base alors je la mets à jour, sinon je l’ajoute ». Le MERGE SQL permet de faire cela très simplement, et bien plus encore, comme vous le pourrez le constater en lisant ce nouveau dossier. Et c’est tellement pratique à utiliser, que je m’en sers maintenant dans tous mes développements, que ce soit en PHP, en RPG ou en PL/SQL (procédures stockées DB2). Il est vrai que j’ai la chance de travailler en ce moment pour des clients dont les serveurs sont en V7R1, ce qui n’est pas le cas de tous mes confrères, malheureusement.

Le seul inconvénient que je verrais dans l’utilisation du MERGE, c’est l’impossibilité de récupérer un « result set » des données impactées par l’instruction. En effet, vous savez peut être (ou peut être pas) que vous pouvez obtenir un « result set » des données modifiées par un DELETE, un INSERT ou un UPDATE, en utilisant la syntaxe SQL DB2 suivante : SELECT * FROM FINAL TABLE (INSERT …).

Cette technique utilisant la clause « FINAL TABLE » peut être très utile pour récupérer la liste des identifiants créés par un INSERT SQL, ou tout simplement le dernier identifiant généré par une série d’INSERT, vous pouvez dans ce cas écrire quelque chose dans ce genre : SELECT MAX(ID) FROM FINAL TABLE (INSERT …).

Le MERGE SQL ne peut pas être combiné avec la clause « FINAL TABLE », donc vous ne pourrez pas récupérer le result set résultant d’un MERGE. C’est à mon avis un inconvénient mineur au vu des possibilités qu’apporte le MERGE.

J’ai d’autres sujets tout aussi intéressants en préparation sur ma « boilerplate » (comme disent les anglais), que je publierai prochainement sur XDocs400.com, comme par exemple :

  • comment contrôler que toutes les jobd pointent bien sur des bibliothèques existantes
  • comment récupérer l’intégralité des postes du scheduler IBMi dans une table (réactualisation en RPG Free d’un vieil article publié sur XDocs400.com)

Ca c’est pour les sujets chauds à paraître dans les semaines à venir. J’en ai aussi d’autres en préparation, mais qui ont besoin de mûrir encore un peu, alors je ne m’étendrai pas davantage, je vous en reparlerai au fil de l’eau.

Sur ce blog, vous trouverez aussi prochainement quelques articles consacrés au langage Javascript (dans le contexte du HTML5), et à différentes techniques assez géniales que j’ai découvertes au cours de mes recherches sur ce langage (notamment sur les polyfills, sortes de librairies destinés à pallier les carences des vieux navigateurs).

Restez à l’écoute.

A très bientôt

Grégory