vendredi 30 juillet 2010

Veille technologique semaine 30

Pour le bulletin de cette semaine, je vous propose les sujets suivants :
  • La dernière version du produit Terracotta permet de gérer des réplications de plusieurs millions d'objets dans un cache d'une taille de 1 Tera octets.
  • Le rôle du manager dans méthode Scrum.
  • La sortie de la spécification OpenGL 4.1 pour le groupe kronos.
  • Sortie de la version 2.2 de l'outil de qualimétries Sonar : personnaliser la page Sonar.
  • Le couplage : comme tout principe, il faut en mettre au bon endroit, avec la bonne dose.
  • La version 5 du langage C# de Microsoft propose d'ajouter la méta-programmation : le programme qui (se) manipule le programme.
  • Sortie de la version 1.3 de VisualVM : visualiser l'exécution de vos programmes dans la JVM : programme écrit en Java, Clojure, Groovy, JRuby, Jython et Scala.
  • Des conseils de Joshua Bloch sur la manière de concevoir des API : "How to Design a Good API and Why it Matters"
  • Quelques détails sur les nouveautés d'eclipse 3.6 : Helios.
  • Quelques exemples d'utilisation des @nnotations Java : comment faire un DSL (Domain Specific Language) interne.
  • Troisième article sur JavaFX : l'asynchronisme.
Bonne lecture.

Terabyte-sized Java apps now possible
The new version of Terracotta's Ehcache Java caching software can hold several hundred million objects simultaneously.

"Building any cache greater than, say, 50 gigabytes is very complex and involves manual work for developers and operators and can be very hard to maintain," Pandey said. "What we have done enables developers and operators to employ a terabyte-scale cache with several hundred million objects."

Manager 2.0: The Role of the Manager in Scrum
When an organization starts to explore Scrum, there's often an uncomfortable moment early on when someone points out that the role of "manager" seems to be missing entirely. "Well I guess we'll have to just get rid of 'em all!" wisecracks one of the developers, and all the managers in the room shift uncomfortably in their seats.

Khronos Group releases OpenGL 4.1, claims to leapfrog Direct3D 11
Just four and a half months after releasing the OpenGL 4 specification, the Khronos Group has released the final version of the OpenGL 4.1 specification. OpenGL 4.0 brought feature parity with Direct3D 11's new features—in particular, compute shaders and tessellation—and with 4.1, the Khronos Group claims that it is surpassing the functionality offered in Microsoft's 3D API.

Sonar 2.2 in screenshots
The Sonar team is proud to announce the release of Sonar 2.2. As usual, this new release includes numerous improvements, bug-fixes
and also brand new features that we believe are worth stopping your daily work for a few minutes to review. Those features can be divided
into three categories :
  • Favourites resources
  • Filters homepage
  • Plugin classloaders

Loose coupling is overrated.
Loose coupling is one of the most desired qualities in modern software development, but because its very subjective nature, and because the lack of analysis on the different types of coupling, some wrong decisions may be taken in the architecture just for the sake of making the application more loosely coupled.

HTML5 @ Zenika-with-Peter-Lubbers
Voici un compte-rendu de la présentation HTML5 de Peter Lubbers de la société Kaazing. Il était invité par Zenika à présenter les grands principes de HTML5 :

HTML5 with Peter Lubbers 1/3
HTML5 with Peter Lubbers 2/3
HTML5 with Peter Lubbers 3/3 

C# 5 and Meta-Programming

To summarize:
C# 1 was all about delivering a new language for a new platform.
C# 2 was all about providing generics to improve strong typing, especially in collection handling situations.
C# 3 was all about letting write strongly typed queries abstracted from the date source. As a consequence C#3 fosters a more declarative way of programming.
C# 4 was mainly about dynamic programming to inter-operate with dynamic programming environment.
C# 5 will be concerned with meta-programming.

Metaprogramming is the writing of computer programs that write or manipulate other programs (or themselves) as their data, or that do part of the work at compile time that would otherwise be done at runtime. In many cases, this allows programmers to get more done in the same amount of time as they would take to write all the code manually, or it gives programs greater flexibility to efficiently handle new situations without recompilation.

VisualVM 1.3: Detailed Application Monitoring
VisualVM 1.3 has just been released and is now available for download at ! The most significant new features in this release include the incorporation of the Sampler plugin into the core tool, the ability to define custom profiling presets, and support for taking a heap dump of a remote JVM. The tool newly enables custom sorting of applications, recognizes the Clojure, Groovy, JRuby, Jython and Scala runtimes, and introduces monitoring remote hosts. Two new plugins have been provided with this release: the Tracer framework and probes plugin enable detailed application monitoring, and the Threads Inspector plugin displays stacks of the selected threads.

Joshua Bloch: Bumper-Sticker API Design
My conference session "How to Design a Good API and Why it Matters" has always drawn large crowds; on InfoQ was the third most viewed content last year. When I presented this session as an invited talk at OOPSLA 2006, I was given the opportunity to write an abstract for the proceedings. In place of an ordinary abstract I decided to try something a bit unusual: I distilled the essence of the talk down to a modest collection of pithy maxims, in the spirit of Jon Bentley's classic Bumper-Sticker Computer Science, Item 6 in his excellent book, More Programming Pearls: Confessions of a Coder (Addison-Wesley, 1988). It is my hope that these maxims provide a concise summary of the key points of API design, in easily digestible form:

Eclipse 3.6 Hidden Treasures
Eclipse 3.6, aka Helios, was released about a month ago. It has become a tradition: this is the time I highlight some of my favorite hidden features in the new release. I focus my article on features which are less obvious, off the beaten path. Features you might not be familiar with if you didn't take the time to read the "new and noteworthy" for this release.
If you haven't done so already, you are invited to read my posts for Eclipse 3.4 (Ganymede) and Eclipse 3.5 (Galileo) (which won the Galileo Blogathon). You can probably pick up some new tricks there as well. I also took the time to reiterate on some of my favorite shortcuts, which made this article a tad longer. As always, if you are familiar with more features which are hidden and worthy, please let me know in the comments.

Patterns for Using Custom Annotations
If you happen to create your own annotations, for instance to use with Java 6 Pluggable Annotation Processors, here are some patterns that I collected over time. Nothing new, nothing fancy, just putting everything into one place, with some proposed names.

Effective JavaFX Architecture Part 3 - Asynchronous calls, Command Pattern and Testability
In the previous installment of Effective Architecture, I covered TDD with Model-View-Presenter. However the code I presented had synchronous server calls. In JavaFX (like Swing), code runs in the Event Dispatch Thread (EDT). It is unwise to block the EDT. Hence it is encouraged to execute all server calls on a separate thread.

jeudi 22 juillet 2010

Veille technologique semaine 29

Pour le bulletin de la semaine 29, je vous propose les sujets suivants :
  • sortie de la version 2.8 de scala : version importante.
  • mise à jour du JDK 6 udate 21 : performance et qualité du garbage collecteur.
  • Netbeans 6.9 et JavaFX 1.3 : avec le composeur visuel.
  • Une pétition pour demander la mise en open sources de JavaFX. 
  • Le JSR 303 - Bean Validation : comment mettre les contrainte de données qui sont vérifiés par le runtime. C'est un mode descriptif (@nnotations).
  • Un article sur Advanced Message Queuing Protocol : un protocole de messagerie interropérable Java, C++, C#, ... Un remplaçant de JMS ?
  • La programmation parallèle et Java : les multi-cores des processeurs modernes demandent au logiciel d'avoir des application multi-threadés pour bénéficier de l'augmentation de puissance de calcul. Le plus difficile est de paralléliser les algorithmes. Une extension du langage Java le propose : [ hello(); || world(); ]
  • Fait-il conserver Internet Exploreur 6.0 ?
Bonne lecture.

Scala 2.8 enfin finale !
Après plusieurs mois de bêtas et de release candidates, voici enfin venir la toute dernière version de Scala en finale à savoir la 2.8.0 ! Cette version quasi majeure est considérée par beaucoup comme une 3.0 tellement les nouveautés sont nombreuses.
Au menu : la nouvelle API collection, la spécialisation de type, une nouvelle implémentation des Array, les arguments nommés et par défaut, les Package Objects, le support des continuations ou bien encore le REPL amélioré. Les nouveautés étant nombreuses, je pense que cette nouvelle version mériterait bien son petit article, n'est-il pas ?
La mise à jour de Scala par votre IDE est possible, pour les autres le téléchargement de la distribution se passe par ici.

JDK 6 Update 21 Release Notes
Java Hotspot VM 17.0
Java SE 6u21 includes version 17.0 of the Java HotSpot Virtual Machine with improvements to overall quality and features such as
compressed object pointers, escape analysis-based optimization, code cache management, the Concurrent Mark-Sweep garbage collector and its successor, the Garbage First (G1) garbage collector.

NetBeans 6.9 Release Supports JavaFX, Java EE6 and OSGi

Oracle has released version 6.9 of its popular open-source Neteans IDE. This is also the first release of the IDE to be released under Oracle's stewardship. The new release has a couple guiding themes providing an umbrella for a raft of new features, as well as many improvements.

First among the additions, and most visible to a user, is the new support for building JavaFX applications using the IDE, called JavaFX Composer. Many have waited for this support for JavaFX to round out the toolkit and the platform. The JavaFX support features a visual designer tool, as well as a code editor. Coders can write code, build them and run them with ease, as well as reformat code files. The visual tools will be the most compelling to users looking to alternatives to Adobe Flash's visual tooling options. The JavaFX composer lets people visually manipulate an application, dragging and dropping components on the screen and arranging them. The tool lets you use - and visually change properties on – all the standard JavaFX components provided with the SDK. JavaFX Composer also provides support for binding web services and databases to components using a generic, abstract idea of data sources and record sets. Accordingly, it's very easy to create these data sources in the IDE.

Open Source JavaFX Petition
To the Leaders, Management, and Board of Directors at Oracle Corporation, We the undersigned formally request that Oracle Corporation release the entire JavaFX Platform as open source software available for modification and reuse by
individuals, educators, and corporations.

Open source software has transformed the way that we build and use software. It has increased the educational reach of technology, allowed new and innovative applications to emerge, and spawned the growth of communities dedicated to
software philanthropy. Java has been at the forefront of this revolution, providing a platform for open source development, and becoming an open source effort in itself.

JavaFX is an innovative technology built on top of Java that allows the creation of next generation Rich Internet Applications (RIA). We believe that an essential part of the future success of this platform is to release it as open source software. This
would increase adoption by companies that fear lock-in or are concerned about technology maturity. It would also make it competitive with other RIA platforms that have embraced the open source model.

Bean Validation
Comment valider un bean ? L'idée de départ, comme toutes les bonnes idées, est très simple.

Avant, pour confirmer que des données étaient valides selon certains critères métiers, le  développeur pouvait être amené à intervenir sur plusieurs couches. Il pouvait agir, par exemple,   sur la couche présentation, en ajoutant du javascript pour contrôler un champ du formulaire, ou  bien ajouter du code de vérification dans la couche DAO avant de persister en base. Cette spécification a eu pour objectif, d'une part d'enrichir les entités métiers sur les valeurs que
pouvaient prendre ses propriétés, et d'autre part de fournir un service capable de valider ces entités avec en plus un certain niveau d'information sur les cas non valides.

La JSR-303, finalisée en novembre 2009, fournit une standardisation de ces concepts et fait partie de Java EE 6. Emmanuel Bernard étant le spec lead de cette JSR, assez naturellement l'implémentation Hibernate Validator est devenue celle de référence. C'est cette dernière qui sera exclusivement évoquée dans cet article.

AMQP, une alternative à JMS ?
AMQP (Advanced Message Queuing Protocol) est un protocole de messagerie créé à l'initiative de  la banque JP Morgan Chase pour gérer la communication entre ses différents partenaires. Le but affiché était de fournir une solution alternative aux solutions payantes et relativement chères dans le domaine du MOM (Message-Oriented Middleware) dominé largement par Websphere MQ
d'IBM et RendezVous de Tibco (93% du marché à eux deux en 2008). Un certain nombre de partenaires se sont fédérés autour de ce projet pour aboutir à une première spécification en 2006. L'ambition avouée est qu'elle devienne l'équivalent du HTTP pour l'internet, ce qui explique qu'elle décrive aussi bien les différentes sémantiques liées au MOM que la partie plus bas niveau du transport de ces messages. Cette normalisation permet la multiplication des solutions clientes ou serveurs dont la compatibilité sera garantie par cette spécification. Par exemple, un broker de message écrit en Erlang comme RabbitMQ transférera de façon
transparente un message d'un client ruby vers un autre client Java/JMS.

Spring facilite l'adoption d'AMQP
Comme on pouvait s'y attendre avec le rachat de RabbitMQ par VMWare, Spring intégre petit à petit des fonctionnalités facilitant l'adoption d'AMQP.
Le premier milestone de Spring AMQP 1.0.0 matérialise cet effort. Un gros point de satisfaction, Spring ne s'est pas contenté de fournir la partie cliente Java de RabbitMQ mais propose une réelle abstraction du protocole AMQ. Par contre la gestion des versions de la spécification reste un peu flou. Elle semble caler sur la version 0.8 tout en étant compatible avec la 0.9.1.
La distribution vient avec 4 modules : spring-amqp, spring-rabbit,spring-rabbit-admin et spring-erlang. Ce dernier est le plus inattendu et la documentation semble indiquer que le projet est expérimental. Pour rappel le serveur de RabbitMQ est implémenté en Erlang, un langage très perfomant sur les aspects concurrentiels.
La documentation, bien qu'incomplète, a la bonne idée de proposer plusieurs cas d'utilisation et laisse entrevoir un bon support pour Spring Integration. Cette nouvelle est quoiqu'il en soit une très bonne nouvelle pour l'adoption d'AMQP dans le monde Java. Par ailleurs Spring propose également une version .Net.

Think Parallel, Think Java
For the most part, parallel programming for today's multicore and manycore
architectures have been purview of C++ (think Intel's Threaded Building Blocks,
Parallel Studio, RapidMind, and Cilk++) and functional languages (Erlang, Haskell,
Scala, and the like). What's missing? How about Java.

In the Java world, Ateji has released Ateji PX for Java, a Java
extension for providing compatibility with existing sequential code, tools, and
training. The extension provides only parallelism-related aspects, with the addition
of a couple of syntactic constructions.

Easy multi-core programming for all
Boost application performance and leverage hardware assets by using all available processor cores The number of cores in desktop computers and servers is expected to double every year. While the OS is able to run different applications on different cores, the only way for an application to benefit from a performance increase is to parallelize the code at the level of the application.

Ateji PX makes this parallelization process simple and compatible with existing Java code.

Ateji PX for Java : "Parallel programming made simple"
Ateji PX for Java introduces parallelism at the language level, extending the sequential base language with a small number of parallel primitives. This makes parallel programming simple and intuitive, easy to learn, efficient, provably correct and compatible with existing code, tools and development processes.

Faut-il continuer à supporter internet explorer 6 ?
On ne va pas ergoter sans fin, tout le monde doit maintenant savoir que Internet Explorer 6 — IE6 pour les intimes — est un navigateur obsolète et dangereux. Et pourtant, certains continuent à l'utiliser. Faut-il les en dissuader, refuser de leur fournir son support, aller même jusqu'à leur empêcher l'accès, ou faut-il continuer à supporter (les faiblesses de) ce navigateur ?

vendredi 16 juillet 2010

Veille technologique semaine 27

Bonjours à tous,

pour le bulletin de cette semaine, je vous propose les sujets suivants :
  • un résumé sur la présentation de JEE 6 par Adam Bien au club Java de PARIS
  • JEE 6 et les événements : natif pour les EJB 3.1
  • un groupe de travail qui démarre une spécification sur les notifications pour le Web
  • la réutilisation : un rêve ? L'article mentionne qu'un excès de configuration complexifie l'utilisation "Maximize reuse minimizes use" : attention aux usines à gaz !
  • Quelques définitions de vocabulaire UML.
  • Les slides sur une présentation au sujet des annotations Java.
  • La surcharge et la redéfinition : deux concepts à ne pas mélanger (respectivement override et overload en anglais).

Bonne lecture.

Java EE 6 par Adam Bien

Lightweight killer apps with nothing but vanilla Java EE 6, par Adam Bien (
Adam est membre du JCP, et a écrit le livre Real World Java EE Patterns.

  • Lightweight ?
  • rapide
  • simple
  • small
  • lean
  • short turnaround cycles : déployer le plus rapidement possible pour être productif
  • easy : convention over configuration

Spring vs JEE : Java EE repose davantage sur les conventions, mais Spring donne davantage accès à toutes les options de configuration. A part ça, leurs fonctionnalités sont grosso modo les mêmes aujourd'hui, c'est une affaire de goûts.
Et les autres langages ? Ruby, Groovy... ? Ce sont des technologies intéressantes, mais du point de vue de l'entreprise, pas encore matures ou reconnues. De plus, il est difficile de trouver des développeurs expérimentés.

Architectures modernes

En Java EE 6, il y a 3 couches : Boundary (interaction avec des systèmes externes : utilisateur ou webservices), Control, Entity.
Pour des applications CRUD, Boundary+Entity sont suffisants, car la plupart du temps la couche service n'est qu'un delegate vers la couche Entity.
On voit ici que le modèle ECB (Entity-Control-Boundary) est indépendant de l'implémentation de Java EE.

Le Domain Driven Design tente de mettre les use-cases métiers au centre du développement. C'est un peu l'inverse de ECB, orienté technique.
Le DDD pousse à avoir un domaine riche, bien encapsulé ; il n'y a donc pas réellement besoin de couche service dans ce cas.
Adam pointe vers le site qui pousse à remplacer les IF par des classes bien encapsulées et l'utilisation des design patterns (Strategy...).
Le DDD est principalement stateful : le graphe d'objet en mémoire contient l'état du système. Il est alors assez difficile de sauvegarder ce graphe en base de données par exemple. Si plusieurs clients (au sens client du système, pas utilisateur) modifient le graphe de manière simultanée, il est difficile de merger leurs modifications.
Par contre, il est possible de tester le système de manière autonome, sans même avoir de base de données, puisque le système est auto-contenu.
Cette approche est "lean" car moins de couches techniques sont mises en oeuvre : les données et leur traitement sont co-localisés. De plus, elle s'interface bien avec les architectures REST : il suffit d'exposer les objets comme des Ressources.

Avec JSF 2, on peut accéder directement à des Managed Beans ou à des EJB, grâce à un Expression Language. La couche de configuration et d'intégration est donc très légère, voire inexistante.
Adam montre le code d'un EJB, et explique qu'il met la visibilité de ses services injectés (ex: EntityManagers) à "packaged", de manière à simplifier les tests unitaites (injection manuelle). Nicolas Martignole intervient en déclarant qu'il utilise plutôt la visibilité publique partout où il peut, et prend en exemple le framework Play. De nombreux développeurs ne sont pas d'accord et rappellent l'utilité des différents niveaux de visibilité et leur impact sur la sécurité et la robustesse du système.

Service-driven architectures
Ces architectures mettent l'accent sur une couche de service indépendante de ses "clients" : interface utilisateur, webservices... Chaque couche est isolée et possède ses propres modèles et traitements.
Elles sont la base des architectures SOA.

SOA vs DDD : les frères ennemis
Les deux sont des bonnes pratiques... chacun dans un contexte particulier.

Au final, le discours d'Adam Bien est assez anti-conformiste : supprimez les interfaces, les DAO, réduisez le nombre de couches !
Assez surprenant dans le context actuel, où les blueprints Spring et Sun sont martelés dans les écoles et les entreprises.

Qu'y a-t-il dans Java EE 6 ?

EJB 3.1
Les EJB 3.1 sont très simples :

public class SimpleSample {
   public void doSomething() {}

Notez qu'il n'y a plus besoin de définir l'interface métier comme dans les EJB 2 ! Il est toujours possible de le faire, mais c'est optionnel.
Mais alors, comment tester ? En fait, il n'y a absolument pas besoin d'interfaces pour tester unitairement : Mockito le fait très bien par exemple. En particulier, les Interceptors fonctionnent directement sur les classes, contrairement aux proxies dynamiques qui demandent la présence d'interfaces.

De même, a-t-on vraiment besoin des DAOs ?
Très généralement, la base de données survit largement aux applications qui y accèdent, il est donc contre-productif (voire stupide) de fournir une couche d'adaptation "au cas où".

JNDI enfin standardisé
... pour des noms enfin portables !

EJB 3.1 + REST
Grâce à l'annotation @Path, on peut exposer un EJB 3.1 en tant que service REST. Pas de XML, pas de configuration de container.

L'annotation @Schedule permet de définir des expressions type "cron" pour scheduler des traitements.

L'annotation @Singleton permet, avec @PostConstruct, de créer des singletons simplement et de manière sûre.

Tâches asynchrones
Les méthodes annotées @Asynchronous sont exécutées dans des transactions en arrière-plan. Elles renvoient des objets de type Future<?>.
L'usage raisonné des méthodes asynchrones peut vraiment faire la différence en termes de performances ! Adam raconte qu'une entreprise était prête à laisser tomber Java pour du C car leurs performances étaient mauvaises. Le fait de configurer certaines méthodes en @Asynchronous a permis de multiplier les performances et ainsi sauver l'application Java.
Les méthodes asynchrones sont exécutées par un pool de threads géré par le container.

Les EJB exposent automatiquement des métriques en JMX.
Selon Adam, la différence de performances entre un Pojo et un EJB est infinitésimale - alors que la possibilité de monitorer l'application en production est "priceless".

CDI est l'héritier des anciennes JSR 299 et 330.
CDI s'inspire de ce qui a été introduit par Spring, mais pousse les possibilités plus loin. En particulier, CDI est type-safe.

Adam a principalement réalisé des démos en "live".
Il a ainsi passé en revue à peu près toutes les fonctionnalités principales de Java EE 6, des EJB aux vues JSF, en passant par les méthodes asynchrones, les intercepteurs, et l'injection avec @Inject (y compris pour injecter un simple POJO qui n'en demandait pas tant !).

Au final, ça donne quand même envie d'y rejeter un oeil, sérieusement.
On est loin des temps préhistoriques du XML à foison, des interfaces atroces (throws RemoteException, ça rappelle des souvenirs à quelqu'un ?), et des fonctionnalités limitées. Comme promis, Java EE 6, et notamment les EJB 3.1, fournit un modèle puissant et léger pour le développement d'applications robustes.

De mon point de vue, le principal défaut de la plateforme est la partie vue. Sérieusement, JSF, même 2.0, c'est... juste horrible. Et son concepteur l'a même avoué : il recommande maintenant de se tourner vers Wicket, pour les projets n'ayant pas un fort impératif d'utilisation des standards.

Le prochain Paris JUG se tiendra en septembre : repos pendant le mois d'août !

Decoupling event producers and event consumers in Java EE 6 using CDI and JMS
In this post I will share my recent findings about Container Dependency Injection in Java EE 6, in particular how to decouple the processing threads of event producers and event consumers.

Java EE 6 introduces a very nice dependency injection framework (CDI) that has superb support for the Observer pattern in the form of event broadcasting.

Web Notification Working Group Charter
The mission of the Web Notification Working Group, part of the Rich Web Client Activity, is to produce specifications that define APIs to generate notifications to alert users. A Notification in this context may be displayed asynchronously and may not require user confirmation. Additionally, events are specified for managing user interactions with notifications.

Reuse: Is the Dream Dead?
In general, the more reusable we choose to make a software component, the more difficult that same software component is to use. In the extreme, an infinitely reusable component is infinitely difficult to use. Dealing with the tension between reuse and use is a complex issue, and often, we fail. Largely, the problem has to do with dependencies.

This statement is a derivation of Clemens Szyperski's statement in Component Software: Beyond Object-Oriented Programming -
"Maximize reuse minimizes use."

Association, Aggregation, Composition, Abstraction, Generalization, Realization, Dependency
These terms signify the relationships between classes. These are the building blocks of object oriented programming and very basic stuff. But still for some, these terms look like Latin and Greek. Just wanted to refresh these terms and explain in simpler

Conférence : Les annotations enfin expliquées simplement
Mardi dernier, j'ai animé chez Zenika une conférence sur les Annotations.
Et le sujet est plus complexe qu'il n'y paraît. Outre les subtilités de leur syntaxe, les annotations disposent d'un outillage puissant à la compilation et au runtime, dont la maîtrise ouvre de nouvelles perspectives en termes de méta-programmation.
En particulier, j'ai démontré l'utilisation des
Annotation Processors, qui permettent d'interagir avec le compilateur Javac, et de la Réflexion pour lire et injecter des annotations dynamiquement au runtime.

Overloading And Overriding
Conceptually overloading and overriding is way different. Only the notion about interface name is same in both cases. Other than that, you cannot find a common thing between them.
Overloading is using the same interface but with different inputs and getting different behaviour as output. Slightly confusing right. I hope by end of this article you may feel better.

vendredi 2 juillet 2010

Veille technologique semaine 26

Pour le bulletin de la semaine 26, je vous propose les articles suivants :
  • Etes vous multi-taches ? On connaît le multi-tâches pour les machines mais qu'en est-il pour les humains ? Des études montrent que au delà de trois tâches, l'efficacité humaine s'effondre. A prendre en compte dans vos activités.
  • Gmail de Google bientôt en HTML 5.
  • Les nouvelles fonctionnalité de l'OS Android 2.2 réalisé par Google, avec bientôt une version sur processeur x86 d'Intel (porté par Intel).
  • Les NIO 2 et le JDK 7 : l'accès aux attributs des fichiers.
  • La différence entre l'identité et l'égalité : exemple en C#
  • Les expressions lambda pour le JDK 7 : étude des différent cas.

Bonne lecture.

Multitasking Gets You There Later
Modern business relies on multitasking to get work done. Employees are evaluated on their ability to multitask. IT professionals are routinely assigned to multiple projects. Did we always do this? Does multitasking work? What are the real impacts of multitasking? Is there an alternative?

Costs of Multitasking
A person who works on more than one project incurs a cost at each shift from one project to the other. The primary cost is the time required to change context. We know that simple interruptions like a phone call can cost as much as 15 minutes of recovery time. The more complex the task, the more time it takes to make the shift.

If you are working on more than two projects the cost can be even greater. It may have been a long time since you worked on that project, taking more effort to remember where you left off. Alternately, if you shift frequently, your context-switching time is a larger proportion of your work time.

There are studies that show people are pretty good at shifting between two contexts for small tasks. In a short time scale this appears to have to do with our two brain hemispheres. To a certain extent, we can parallel process two independent tasks. For larger switches, we should expect some switching cost. Jerry Weinberg showed the escalating context switching costs accrued if each task has a 10% penalty, in reality the costs are frequently higher.

Google Gmail to harness HTML5
Google announced that it would be rendering many upcoming features for Gmail in HTML5.  Dragging and dropping files from the desktop into the browser will be just one new feature in Gmail's new standards-based update.  Google will also leverage HTML5's database standards (migrating away from the now-dead Google Gears storage; in favor of HTML5 Web Workers).

Cool Off This Summer with Fully Native x86 Froyo  
A senior VP at Intel has recently
stated that a fully native x86 version of Android 2.2 will be released this Summer.  All of the code will be sent back to the open branch being created for x86.  This could mean more Atom-powered Android tablets.

Introducing NIO.2 (JSR 203) Part 3: File System Attributes and Permissions support in NIO.2
In two previous entries I covered Introducing NIO.2 (JSR 203) Part 1: What are new features? and Introducing NIO.2 (JSR 203) Part 2: The Basics [2] In this entry I will discuss Attributes introduced in NIO.2. Using attributes we can read platform specific attributes of an element in the file system. For example to hide a file system

Comparing Values for Equality in .NET: Identity and Equivalence
The various ways of comparing two values for equality in .NET can be very
confusing. In fact if we have two objects a and b in C# there are at least
four ways to compare their identity, plus one operator that looks like an
identity comparison to add to the confusion:
1. if (a.Equals(b)) {}
2. if (object.Equals(a, b)) {}
3. if (object.ReferenceEquals(a, b) {}
4. if (a == b) {}
5. if (a is b) {}

As if that isn't confusing enough, these methods and operators behave
differently depending on:
whether a and b are reference types or value types
whether they are reference types which are made to behave like
value types for these purposes (System.String is one of these)

This article is an attempt to clarify why we have all these versions of equality, and what they all mean.

Lambdas in Java: An In-Depth Analysis
With the acquisition of Sun Microsystems out of the way, Oracle can get down to the serious business of revitalising what many have come to see as a stagnant language. High on many people's requirements is the ability to be able to pass functions around that are independent of classes, so that functions can be used as arguments to other function or method calls. Functional languages like Haskell and F# exist purely using this paradigm, and functional programming goes back eight decades to the Lambda Calculus, leading to the term Lambda being used in many languages to describe anonymous functions.