Veille technologique semaine 17

Pour le bulletin de cette semaine, je vous propose les sujet suivants :

• Les navigateurs web et le "Do Not Track" : il n'y a pas encore de consensus.
• Un article sur le dette technique des systèmes d'informations
• Le modèle de compétence de Dreyfus : comment gérer ses connaissances et les faire évoluer.

• Introduction au langage de requête LINQ avec C#
• Exemple de langage de requête pour Java : Querydsl

• Les nouveaux langages pour la JVM : discussion depuis la proposition du langage Ceylon
• L'outil de qualimétrie Sonar : donner accès simplement à une synthèse des métriques sur du code source. Sept axes sont identifiés : Duplicated code, Coding standards, Unit tests, Complex code, Potential bugs, Comments, Design and architecture.
• Un petit tutorial sur les types paramétrés : les génériques en Java
• Les varargs en Java :
• La sortie de la version 1.8 du langage Groovy avec un exemple pour la programmation par contrat : @Invariant, @Requires and @Ensures

Bonne lecture.


Google et Opera bloquent sur Do Not Track
Le président de la Federal Trade Commission américaine, Jon Leibowitz, s'est ému que Google, contrairement à Mozilla, Microsoft et apparemment Apple, ne se soit pas engagé en faveur de l'initiative "Do Not Track".

Celle-ci permet à l'internaute de spécifier de manière définitive aux sites web s'il accepte ou non que ses informations de navigation soient traitées par les annonceurs afin de recevoir des publicités ciblées ou de connaître ses déplacement entre les sites. Encore faut-il évidemment que les sites récupèrent et acceptent cette demande transmise par le navigateur web (lire aussi Mozilla et Google proposent la fin du tracking).


L'endettement de nos systèmes d'information
Ward Cunningham introduisait en 1992 la métaphore de la dette technique faisant une analogie entre les coûts futurs liés aux choix de conception logicielle et une dette financière.

Pour illustration, l'éditeur CAST Software a publié un rapport qui évalue le montant moyen de la dette technique à 2,82$ par ligne de code. Le sujet de la dette technique n'est pas tant le montant que son échéance – mais date à laquelle il devient nécessaire d'apurer la dette technique – et ses intérêts – surcoûts liés à une conception technique peu flexible.



Le modèle Dreyfus d'acquisition de compétences.
Ce modèle dit que le passage de novice à expert d'un domaine donné passe par cinq étapes.

étape 1: Novice

• l'activité change sa manière de penser car il acquiert de l'expérience dans un domaine qu'il ne connaît pas, ou peu.
• il focalise sur le besoin, l'objectif immédiat.
• l'accomplissement de ses tâches nécessite des recettes, une marche à suivre.
• il n'a pas d'intuition sur la manière de résoudre les problématiques.

étape 2: Débutant avancé

• il fait preuve d'indépendance technique et sait chercher l'information nécessaire à l'accomplissement de ses tâches.
• il sait choisir quelle démarche et technique appliquer selon le contexte.
• il ne comprends pas ou peu la stratégie globale du système, de l'entreprise; il ne voit généralement pas les liens avec son travail quotidien.

étape 3: Compétent

• il peut développer et utiliser des modélisations des problématiques et travailler par abstractions.
• il peut résoudre des problèmes qu'il n'a pas rencontré auparavant.
• on dit d'eux qu'ils font preuve d'initiative.
• il ne réfléchit pas ou peu sur ses méthodes de travail, ne rentre pas dans un processus d'amélioration continue.

étape 4: Spécialiste

• il ressent le besoin de comprendre la vue générale et les détails, la sur-simplification le frustre.
• il corrige ses erreurs.
• il apprend par l'expérience des autres, étudie des cas, des projets et prends ce qui peut améliorer son expertise.
• il comprends et applique des maximes, vérités essentielles "Fait le minimum qui peut fonctionner", "Ne te répète pas", "Teste tout ce qui peut casser", ...
• il sait utiliser les modèles de conception quand nécessaires (ce ne sont pas des recettes) et les adapter .
• il utilise les avantages de la réflexion et du retour d'informations qui sont au cœur des méthodes agiles

étape 5: Expert

• il cherche continuellement des nouvelles méthodes et manières de mieux faire les choses.
• il travaille par (bonne) intuition.
• il peut avoir du mal à expliquer ses choix: ils lui semblent "naturels".
• il distingue les détails futiles de ceux très importants.
• peu d'experts existent: certainement entre 1 et 5 pourcent de la population.

A noter qu'on peut être expert dans un domaine et totalement novice dans un autre.

Si le novice ne cherche pas à diversifier son expérience (ou ne suit pas de formation), il peut rester novice dans ce domaine quelque soit le nombre d'années d'activité. De même pour passer de débutant à compétent.

Nous tendons à penser que la plupart d'entre nous est au niveau "Compétent". Or il apparaît en pratique que la grande majorité est au stade "Débutant avancé".

Nous nous estimons aisément expert d'un domaine et sûr de nos choix lorsqu'on possède peu de compétences et connaissances de ce domaine. Un novice ne connaît peu ou pas les limites de son savoir. Plus on est expert, plus on doute, on se sent ignorant.


Le modèle d'acquisition de compétences de Dreyfus
Le modèle de Dreyfus n'est pas un modèle théorique mais plus un modèle pragmatique qui fournit une grille de lecture de l'apprentissage de nouvelles compétences. Il permet ainsi de concevoir des cours et supports permettant un meilleur apprentissage de compétences de haut niveau.


Introduction aux requêtes LINQ (C#)
Une requête est une expression qui récupère des données d'une source de données. En général, les requêtes sont exprimées dans un langage de requête spécialisé. Au fil du temps, différents langages ont été développés pour les divers types de sources de données, par exemple, SQL pour les bases de données relationnelles et XQuery pour le XML. Par conséquent, les développeurs ont dû apprendre un nouveau langage de requête pour chaque type de source de données ou format de données qu'ils doivent prendre en charge.

LINQ simplifie cette situation en proposant un modèle cohérent qui permet d'utiliser des données de types de sources et de formats divers. Dans une requête LINQ, vous travaillez toujours avec des objets. Vous utilisez les mêmes modèles de
codage de base pour interroger et transformer des données en documents XML, en bases de données SQL, en groupes de données ADO.NET, en collections .NET et en tout autre format pour lesquels un fournisseur LINQ est disponible.


Querydsl
Querydsl is a framework which enables the construction of type-safe SQL-like queries for multiple
backends including JPA, JDO and SQL in Java.
Instead of writing queries as inline strings or externalizing them into XML files they are constructed via
a fluent API.
Code completion in IDE (all properties, methods and operations can be expanded in your favorite Java IDE)
Almost no syntactically invalid queries allowed (type-safe on all levels)
Domain types and properties can be referenced safely (no Strings involved!)
Adopts better to refactoring changes in domain types
Incremental query definition is easier


Querydsl Reference Documentation


Creating a new JVM language
Last week's announcement of Ceylon brought the focus on JVM-based languages. Ceylon isn' the first JVM based language; nor will it be the last. But the general case of JVM based languages was proposed in Bruce Tate's Beyond Java in 2005, and has been a focus of the Java platform for a significant time, as the list of JVM languages on Wikipedia can attest to. Bruce noted that community is the key to success:


Sonar - Monitor Project and Code Quality
What is Sonar ?
Sonar is an open source Platform used by development teams to manage source
code quality. Sonar has been developed with a main objective in mind: make code
quality management accessible to everyone with minimal effort.
As such, Sonar provides code analyzers, reporting tools, defects hunting modules
and TimeMachine as core functionality. But it also embarks a plugin mechanism
enabling the community to extend the functionality (more than 35 plugins
available), making Sonar the one-stop-shop for source code quality by addressing
not only developers but also managers needs.
In terms of languages, Sonar support analysis of Java in the core, but also of Flex
(ActionScript 3), PHP, PL/SQL and Cobol through plugins (Open Source or
commercial) as the reporting engine is language agnostic.

Java Generics Tutorial
Generics is a Java feature that was introduced with Java SE 5.0 and, few years after its release, I swear that every Java programmer out there not only heard about it, but used it.
There are plenty of both free and commercial resources about Java generics and the best sources I used are:
• The Java Tutorial.
• Java Generics and Collections, by Maurice Naftalin and Philip Wadler.
• Effective Java (second edition), by Joshua Bloch.

This blog post is made up of the following parts:
Part I - The Basics
Part II - Subtyping
Part III - Wildcards



Java Varargs Corner Case
Recently I have been playing with the Omniscient Debugger (or ODB), which is pretty cool in its own right, but in the course of playing with the code I ran into some vararg behaviour which was unexpected.
Varargs, or variable arguments were introduced in Java 5 to support some features available in other languages. The basic idea is that a method doesn't need a defined number of parameters and can accept any number of parameters made up of fixed and variable parameters provided:

• The variable parameters all have the same type
• There are zero or variable parameters
• There is only one set of variable parameter
• The variable parameters come last in the parameters

Welcome to GContracts – A Programming by Contract Extension for Groovy!
This project aims to provide contract annotations that support the specification of classinvariants, pre- and post-conditions on Groovy classes and interfaces. In addition, GContracts supports postconditions with the old and result variable and inheritance of all assertion types.
Applying @Invariant, @Requires and @Ensures
With GContracts in your class-path, contracts can be applied on a Groovy class or interface by using one of the assertions found in package org.gcontracts.annotations.