Voici un cours d'introduction à Java qui date un peu (dernière mise à jour significative en 2005-2006), mais qui sait cela peut servir. La présentation est également disponible sur SlideShare. Ce cours s'adresse à des étudiants niveau Bac +3/Bac +4 connaissant déjà C et C++.
Entre temps, JavaFX a changé (moi aussi d'ailleurs mais c'est une autre histoire :-P) et comme je suis en train de m'essayer à nouveau à JavaFX, voici une nouvelle version d'un dessin de cardioïde avec JavaFX.
Cela donne cela :
Rien de bien extraordinaire dans le code. Le Slider permet de modifier la taille du cardioïde. Sont utilisés ici les capacités de binding de JavaFX (entre le paramètre rho de la courbe paramétrique et la valeur sélectionnée par le Slider ; pour plus d'information sur la cardioïde voir http://fr.wikipedia.org/wiki/Cardio%C3%AFde).
La fonction generatePath retourne une séquence de coordonnées x et y correspondant à la cardioïde par rapport à la valeur du paramètre rho. Cette séquence de coordonnées est utilisée par la Polyline.
Désolé, en ce moment je m'intéresse à JavaFX et après une longue période d'inactivité sur ce blog qui faisait elle-même suite à une période d'activité très modérée, je publie coup sur coup plusieurs vidéos de Sun sur JavaFX... Je trouve que cette technologie est vraiment devenue intéressante et qu'elle mérite qu'on y jette un oeil, voire plus si affinité. Sun a quand même mi presque 2 ans à proposer quelque chose qui tienne la route face à Flex ou à Silverlight mais là la technologie commence à être mature et utilisable. L'intérêt est quand même de rester sur une plateforme Java.
Cette vidéo n'est pas vraiment une introduction. C'est plutôt une vidéo de présentation du concept de "Scene Graph", élément essentiel de JavaFX. La vidéo est courte et complète bien les 2 vidéos d'introduction de Sun publiées dans mes 2 derniers billets sur JavaFX.
La présentation dure environ 6 minutes, dont seule les 5 premières minutes ont réellement un intérêt pédagogique (c'est de bonne guerre, la fin de la présentation donne des informations sur le site www.javafx.com, et comment retrouver les informations et exemples dont il est question dans la présentation).
Cette courte vidéo présente les classes et concepts fondamentaux pour réaliser des applications graphiques avec JavaFX (ce qui est il faut bien l'avouer la raison pour laquelle en général on se penche sur JavaFX :-P).
La classe Stage représente le conteneur de haut-niveau (top-level container) qui correspond à une fenêtre classique par défaut mais peut être transparente ou sans la bordure et les autres "décorations" associées.
Un objet Stage contient un attribut scene de classe Scene. La classe Scene correspond à une surface de dessin pour y placer le contenu graphique. Un objet Scene a un attribut content qui est une séquence d'élément dans le Graph Scene (La traduction en graphe de la scène ne me plait guère est à défaut d'une qui me satisfasse, je préfère utiliser le terme anglais).
Le Graph Scene est un concept important de JavaFX : le contenu graphique est considéré comme un graphe d'éléments. Attention, il s'agit bien d'un graphe et non d'un arbre, il n'y a donc pas d'élément racine. C'est pour cela que l'on a une séquence d'éléments, pouvant eux-mêmes être constitués de séquence d'éléments.
Ces éléments graphiques peuvent être des classes Node, Group ou CustomNode. Un Node est une feuille du graphe, c'est-à-dire qu'il ne peut pas avoir de noeud graphique fils. Par contre, tout comme les 2 autres classes, un objet Node peut avoir 0 ou 1 parent. Les formes (Shape) et les éléments d'interface venant de Swing (slider, label, etc.) sont par exemple des Node.
Un Group est un regroupement de plusieurs Node, Group ou CustomNode. Un Group peut ainsi permettre de créer des formes complexes en regroupant plusieurs formes. De plus un objet Group permet d'appliquer un même effet à tous les élément du groupe en question. Ainsi un objet Group permet de manipuler un ensemble d'éléments graphiques comme un élément unique.
Enfin, la classe CustomNode est une classe abstraite que l'on sous-classe et dont on redéfinit (utilisation du mot clé override) la fonction create() qui définit le contenu de cet élément.
Voici une vidéo d'introduction à JavaFX qui fait suite à celle que j'ai posté dans mon billet précédent sur ce sujet.
Toujours en une quinzaine de minutes, cette vidéo présente des fondamentaux de JavaFX, en ce concentrant cette fois-ci sur les éléments de base pour produire des graphiques avec JavaFX alors que la première vidéo de cette série se focalisait sur les fondamentaux du langage.
Sans remplacer les tutoriaux, ces vidéos donnent une vision synthétique et rapide des différents aspects et peuvent ainsi servir de mise en jambe ou d'aide-mémoire.
Si vous souhaitez avoir une meilleure qualité de vidéo, je vous invite à la récupérer via Miro, une petite recherche sur "JavaFX" devrait vous permettre de les trouver facilement.
Voici une présentation des bases de JavaFX par Robert Eckstein de Sun. La présentation est bien faite et en 15 minutes donne tous les éléments de base nécessaire à un développeur Java pour se faire une idée sur ce nouveau langage.
Je m'étais intéressé à JavaFX en 2007. Je n'avais pas été convaincu à l'époque par la le langage et la plateforme qui - il est vrai - venait de sortir et manquait probablement de maturité.
Récemment (on va dire que cela fait un petit mois), j'ai ré-essayé et je suis par contre cette fois séduit. De gros progrès ont été réalisés, avec Netbeans vous avez maintenant un vrai IDE pour travailler avec JavaFX (il existe également un plugin Eclipse mais je ne l'ai pas essayé). Cette fois-ci je pense que cette plateforme "RIA" devient crédible par rapport à la concurrence. Bien sûr qu'elle s'impose c'est une autre histoire mais elle a des atouts indéniables. Reste à voir également comment le rachat de Sun par Oracle fera évoluer la stratégie par rapport à cette plateforme.
Ci-après une présentation de Ruby 1.9 par son créateur en personne... bon, cette vidéo date un peu (fin février 2008) mais je n'avais pas eu le temps de la regarder avant.
La présentation est relativement courte (une grosse demi-heure sans les questions) et va à l'essentiel. Ce que j'ai surtout retenu pour ma part, c'est que la version 1.8 est la dernière version stable assurant une compatilité ascendante avec les versions antérieures de Ruby alors que dans la 1.9, Yukihiro Mastumoto n'a pas hésité à casser ces compatibilités pour corriger ce qu'il considérait comme des erreurs de conception. Ce qui est important aussi avec la version 1.9 est le support d'Unicode (ce qui est un peu une des faiblesses de Ruby, si j'ai bien compris... mais bon je suis loin d'être un spécialiste en la matière) et une modification de la VM de Ruby qui semble apporter des améliorations de performance.
Ci-après, une présentation vidéo (un peu longue : un peu plus d'1h30) sur le langage Factor de Slava Pestov (qui est aussi le créateur de l'éditeur jEdit).
Factor est un langage de programmation dynamique concaténatif, dont les principales influences sont Joy, Forth, Lisp et Self.
Dans un langage concaténatif la composition de fonction est dénoté par juxtaposition contrairement à des langages applicatifs (traduction libre et probablement incorrecte de l'anglais "applicative language").
Dans un "applicative language" pour exprimer la composition de la fonction G de x par la fonction F vous serez amené à écrire quelque chose de la forme F(G(x)). Dans un langage concaténatif comme Factor vous écrirez x G F.
Comme les autres langages concaténatifs et comme l'exemple ci-dessus le laisse entrapercevoir, Factor utilise une syntaxe postfixée, ce qui signifie que vous écrivez les arguments d'une fonction avant son nom. Ainsi pour afficher le fameux "hello world" vous écrirez en Factor la ligne suivante :
"Hello world" print
Pour ce qui concerne Factor, tout comme l'un de ces ancêtres - Forth - c'est un peu plus subtil : c'est un langage de pile ("stacked-based language"). Dans un langage de pile, vous n'appelez pas une fonction ou une procédure en lui passant des arguments, vous déposez des arguments sur la pile et la fonction (en Factor ou en Forth on parle de mot ("word") dépile le nombre d'arguments dont elle a besoin de cette pile. Ainsi dans l'exemple "Hello world" print, en fait le littéral "Hello world" est déposé sur la pile, le mot print le dépile et réalise un affichage.
La programmation avec Factor est donc particulièrement dépaysante si vous n'avez pas déjà tâter de Forth ou de la programmation sous les calculatrices scientifiques HP.
Si le coeur de Factor est clairement du Forth, il propose un système de macros proche de celui de Lisp. De plus, tout comme Smalltalk, Lisp ou Forth, c'est un véritable environnement de développement qui est mis à votre disposition, que chaque création de nouveau mot vient enrichir. Par contre, il n'y a pas à proprement parler d'IDE façon Eclipse ou Netbeans.
Néanmoins, si Factor est un langage original sur bien des points, son créateur a une visée pragmatique : le système est multiplateforme (Windows, Linux, Mac), il propose tout ce dont un développeur peut actuellement souhaiter (GUI, API réseau, API pour le développement Web, tests unitaires, expressions régulières, I/O, etc.). Bref, ce n'est pas juste un langage jouet dans lequel on ne fera que de petits programmes, mais bien un langage complet qui permet de tout faire.
Idéal pour les geeks qui ont envie d'apprendre un nouveau langage complètement différent et qui va bousculer leurs habitudes mais n'ont pas envie de se retrouver limité par les possibilités des bibliothèques. Si vous pensez comme Alan Perlis que "A language that doesn’t affect the way you think about programming is not worth knowing", alors il est clair que Factor vaut très certainement le temps que vous lui consacrerez.
Par contre pour apprendre Factor mieux vaut ne pas avoir de problème de compréhension avec l'anglais et si tutoriaux et autres documents pour apprendre le langage existe, on ne croule pas sous le nombre. Par contre l'existant, au moins pour démarrer est complet.
Une petite vidéo qui explique comment installer et utiliser le plugin Eclipse pour faciliter le développement de projet utilisant Google Data en Java :
Par contre, j'ai fait l'essai avec Eclipse 3.4 (Ganymede), et si l'installation du plugin ne pose pas de soucis, la création d'un projet avec ce dernier n'a pas abouti. Dommage... comme écrirait Isaac Asimov, cela sera certainement pour Noël sur Ganymède... désolé je n'ai pas pu m'empêcher... shame on me ;-)
Ci-après, une courte vidéo d'introduction à "Google Data" pour ceux qui ne connaissent pas :
En tous les cas, le plugin semble intéressant dès l'instant où l'on souhaite réaliser des développements autour de l'API Google Data.
Google a mis a disposition récemment, un outil utilisé en interne : les "Protocol Buffers".
Ces "Protocol Buffers" sont la solution maison de Google "indépendante de la plateforme, indépendante du langage et extensible" pour sérialiser/désérialiser des données structurées.
Il faut d'abord définir un protocole - c'est-à-dire la manière dont les données sont structurées - dans un fichier avec l'extension .proto. Puis ce fichier .proto est compilé avec l'outil protoc pour générer un format binaire compact et le code source dans le langage adéquat (Java, Python et C++ pour l'instant) pour lire et écrire dans fichiers dans ce format de manière transparente.
Les données dans le fichier de protocole sont typées : sont disponibles des types simples génériques correspondant aux types simples des langages cibles. Et il est également possible de définir des nouveaux types dans le fichier de protocole.
Les "Protocol Buffers" semblent pour l'instant être utilisés principalement avec du RPC (Remote Procedure Call) ou pour stocker des données structurées simples.
En fait par rapport à XML, l'avantage des "Protocol Buffers" est d'être un format compact dont le traitement est rapide et facile (comparée à la manipulation d'arbres DOM en XML). Par contre, les "Protocol Buffers" ne sont pas conçus pour des données structurées complexes, dans lesquelles la structure est elle-même significative, comme par exemple une structure décrivant un document.
Si dans la petite vidéo qui suit, une comparaison des "Protocol Buffers" est effectuée avec XML et IDL/Corba (les "Protocol Buffers" sont un outil de sérialisation/desérialisation utilisable dans du RPC mais ne sont pas une solution de RPC), il n'y a pas de comparaison avec JSON et YAML. Ces 2 formats sont beaucoup plus compacts que XML mais le sont moins qu'un format binaire, mais reste par contre "lisible par un être humain".
Enfin, un aspect mis en avant et qui semble en effet un point important c'est l'extensibilité des données mises en oeuvre par les "Protocol Buffers". En effet, il semble possible de faire évoluer le format du protocole, en ajoutant des nouveaux champs par exemple, sans pour autant gêner les applications qui utiliseraient l'ancien format. Bien sûr, il faut voir jusqu'à quel point on peut faire évoluer un protocole sans que cela est d'impact sur l'existant.
Encore un outil de Google pour les développeurs même si ces derniers doivent d'abord déterminer si cela peut convenir à leur besoin. Cependant cela peut être une solution de sérialisation/déserialisation séduisante et dans tous les cas à étudier. Surtout qu'il va certainement rapidement y avoir des bindings ou des mises en oeuvre pour d'autres langages que Python, Java et C++.
Encore un passionné de développement logiciel et de programmation qui se sent obligé de faire un blog.
Le contenu de ce blog reflète uniquement mes opinions personnelles et en aucun cas les opinions d'un de mes employeurs précédents ou de mon employeur actuel.