Veille technologique semaine 16

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

• Google et son hébergement d'application avec Google App Engine : depuis l'annonce par Google, un certain nombre de retours d'expériences sont publiées. Toutes relativement positives. C'est bien une annonce majeur dans l'hébergement d'application sur une JVM. Il faut bien comprendre que, en plus du langage Java, JRuby et Groovy sont aussi accueillis. Bientôt scala et peut-être Jython ?
• Toujours Google, avec la sortie de la plate-forme Java pour les smart phones : Androïde en version 1.5.
• Enfin Terracotta qui sort la version 3 du produit Terracotta DSO (Distributed Shared Object). Cette solution de distribution d'objets (réplication entre JVM) a fait de très gros progrès en terme de performance : plus de 2000 transactions par seconde par core de CPU. Cette solution est toujours la plus performante en terme de productivité avec plusieurs ordre de grandeur.

• Le profile UML pour les architectures SOA est proposé par l'OMG : SoaML. On peut remarquer la présence de THALES et Softeam comme contributeur à cette spécification.
• Les chercheurs d'IBM qui prédisent la fin de la loi de Moore !
• Un article au sujet des langages de description d'architecture logiciels. On peut constater que l'industrie du logiciel est à la préhistoire de ces pratiques, et que la séparations des préoccupations est encore très loin d'être mise en oeuvre. Le mélange du code métier avec le code technique fini par être un amas de code inextricable. L'architecture logicielle est encore trop dépendante des socles techniques, alors que le cycle de vie de nos systèmes est supérieur à cycle de vie des technologies : il faut se débarrasser de cette dépendance et avoir un langage de description de l'architecture logicielle qui soit agnostique (ne connais pas et ne veut pas connaître : pas de dépendance) du socle technique.
• SUN prépare la prochaine session de JavaOne pour Juin 2009 à San Francisco : la plus grande exposition du monde Java.

• Un article sur le prochain garbage collector du JDK 7 porté sur le JDK 6 update14 (bientôt disponible). C'est un très grand progrès sur la réduction du temps de latence lié au garbage collecteur : réduction jusqu'à un rapport 10. Avec un article technique qui complète.
• Une doc sur JUnit et EasyMock : à grader à coté du clavier.

Bonne lecture.

Google App Engine pour Java et Groovy

Google App Engine, solution de Cloud Computing proposée par Google supporte depuis la semaine dernière (en plus du langage Python disponible depuis un an) le langage Java. Cette solution permet dorénavant de déployer son application web à base de servlets (sous forme de war) sur un serveur virtuel hébergé sur l'infrastucture de production de Google (Google a donné la semaine dernière un compte Google App Engine Java aux 10 000 premiers inscrits).

Google met en avant les avantages suivants :

La facilité d'utilisation via un SDK très documenté et des plugins Eclipse.
La scalabilité gérée de manière transparente et automatique
La fiabilité et la performance fournies par les infrastructures de Google
Enfin, App Engine est gratuit si votre serveur n'excède les 500 Mo de stockage et 5 millions de page visualisées par mois

Google fait une entrée de manière fracassante dans le marché du cloud computing "Java" (Amazon EC2, etc.. ) et propose une offre séduisante où chacun peut créer, tester et déployer son application facilement. La création d'un projet App Engine sous Eclipse via le plugin est simple et le déploiement sur App Engine s'effectue en un seul clic.

Quelques liens utiles :

vous pouvez trouver une description très complète de la solution (en Français) sur le blog de Frank Arnulfo
David Gageot a mis en ligne une feuille Google Spreadsheet qui liste les librairies et frameworks Java supportés par Google App Engine
Groovy est également supporté, retrouvez l'annonce sur le blog de Guillaume Laforge


AppEngine et Azure, la synthèse

• Pourquoi cette annonce est-elle affichée partout comme une révolution ?
• Quelles sont les implications pour les entreprises et le logiciel en général ?
• Pourquoi ferais-je confiance à Google pour héberger mon SI ?
• Que vaut la plateforme technique GAE/J de Google aujourd'hui ?
• Comment se situe AppEngine par rapport à Azure ?
• Le mot de la fin ...

Google App Engine et Java: une révolution ?

• GAE c'est quoi ?
• Contraintes et persistence de données
• Console d'Administration
• Versioning
• Développement/Déploiement & GWT:
• Coûts ?
• Ouverture de GAE à d'autres langages
• Cron , Secure Data connector
• Conclusion : Révolution ?

Mobilité Preview d'Android 1.5

En attendant la sortie finale d'Android 1.5 (Cupcake) à la fin du mois, Android Developers Blog annonce la sortie d'une pré-version du SDK 1.5 pour les développeurs d'applications Android.
Parmi la liste complète des nouveautés d'Android 1.5, cette pré-version du SDK propose notamment:

• le clavier virtuel
• le développement de widgets pour l'écran d'accueil (à l'image de l'horloge ou du widget de recherche qui existent déjà dans Android)
• la fonctionnalité live folders
• la reconnaissance vocale

Ce nouveau SDK propose également une avancée intéressante : la possibilité de gérer plusieurs versions du SDK en parallèle, par exemple ici les versions 1.1 et 1.5. Les développeurs pourront donc tester leur application sur plusieurs environnements sans manipulations fastidieuses.
Afin de commencer à tester vos applications sur cette nouvelle version d'Android, vous pouvez télécharger ce SDK 1.5 en cliquant ici.


Terracotta Distributed Shared Objects 3.0 released
Terracotta has announced the release of Terracotta 3.0, adding a new operations center, a very nice developer console that shows you the health and performance of your cluster, and adding many new certified platforms.

Terracotta provides a distributed object heap, where you specify a set of instances and class types as being shared among various JVMs. The client connects to a DSO server in a form of hub and spoke network architecture, and any changes to the shared objects get propagated to every other participating client JVM.

The servers can be striped and can also manage hot failover between primaries and backups.

The developer console looks particularly nice, showing heap and runtime statistics information, as well as diagnostics covering your cluster performance.

DSO comes in an "ES" edition, which is OSS and lacks some of the more sophisticated networking capabilities, and also has commercial versions which provide access to the full feature set.


UML-based SoaML attacks SOA services modeling issues
SOA has made progress through the years without an associated language - and some people would say a SOA language in itself would not be a good idea, thank you very much. But what about a UML profile that might help architects and developers better describe the services at the heart of SOA?

That is in part the goal of SoaML, the Service oriented architecture Modeling Language. This spec, fashioned as a profile of UML, has spent a couple of years going through the standards processes of the Object Management Group (OMG) and appears to be nearing finalization. Sponsors include Capgemini, EDS, IBM, ModelDriven Solutions, and others.

The SoaML cause last month advanced further when the NoMagic modeling concern bundled open-source ModelPro with SOAML in its Cameo SOA+ suite. This combo supports a graphical approach to services modeling.




Report: IBM researcher says Moore's Law at end
Moore's Law is maxing out. This is an oft-made prediction in the computer industry. The latest to chime in is an IBM fellow, according to a report. Intel co-founder Gordon Moore predicted in 1965 that the number of transistors on a microprocessor would double approximately every two years--a prediction that has proved to be remarkably resilient. But IBM Fellow Carl Anderson, who researches server computer design at IBM, claims the end of the era of Moore's Law is nigh, according to a report in EE Times. Exponential growth in every industry eventually has to come to an end, according Anderson, who cited railroads and speed increases in the aircraft industry, the report said.


Architecture as Language :
Architecture is typically either a very non-tangible, conceptual aspect of a software system that can primarily be found in Word documents, or it is entirely driven by technology ("we use an XML architecture"). Both are bad: the former makes it hard to work with, and the latter hides architectural concepts behind technology hype.

What can be done? As you develop the architecture, evolve a language that allows you to describe systems based on this architecture. Based on my experience in a number of real-world projects, this makes the architecture tangible and provides an unambiguous description of the architectural building blocks as well as the concrete system while still staying away from technology decisions (which then can be made consciously in a separate step).

... They had no language to talk about the system...

This is actually a very common observation when I arrive in projects to help out. And of course this is something which I think is a huge problem: if you don't know the kinds of things from which your system will be composed it is very hard to actually talk about, describe, and of course build the system consistently. You need to define a language.

...

Conclusion
Using the approach, we were able to quickly get a grip towards the overall architecture of the system. We also were able to separate what we wanted the system to do from how it would achieve it: all the technology discussions were now merely an implementation detail of the conceptual descriptions given here (albeit of course, a very important implementation detail). We also had clear and unambiguous definition of what the different terms mean. The nebulous concept of component has a formal, well-defined meaning in the context of this system.




Java + You = Innovation
It's that time of year again. The 2009 JavaOne conference takes place at the Moscone Center in San Francisco from June 2-5 and is being sponsored by Intel (a Platinum sponsor), JBoss, and Sony Ericsson. This year's technical and Birds-of-a-Feather (BOF) sessions are organized around four topics: Rich Media Applications and Interactive Content; Mobility; Services; and Core Technologies.



Sun's Garbage First Collector Largely Eliminates Low Latency/High Throughput Tradeoff
Sun's Garbage First garbage collector (hereafter referred to by its nickname G1) is the new low latency garbage collector planned to replace CMS in the Hotspot JVM. It is a server-style collector, targeted at multi-processor machines with large amounts of memory. There are two major differences between CMS and G1. The first is that G1 is a compacting collector. Compacting, a process by which live objects are moved over free memory space towards one end of the heap so that the other becomes one contiguous free area of memory, is important in long running applications because it is inevitable that the heap will fragment over time. G1 compacts sufficiently to completely avoid the use of fine-grain free lists for allocation, which considerably simplifies parts of the collector and mostly eliminates potential fragmentation issues. As well as compacting, G1 offers more predictable garbage collection pauses than can be obtained with the CMS collector and allows users to set their desired pause targets. This strong determinism gives G1 some of the characteristics of a true real-time collector but it isn't genuinely hard real-time since factors like OS scheduling still mean that the pauses cannot be guaranteed. It is however considerably easier for developers to use than the Java real-time products since existing code is able to take advantage of the improved performance that it offers without needing to make any code-level changes. G1 uses a number of interesting techniques, based on global marking information and other metrics, to prioritise regions for collection according to their GC efficiency. A previous InfoQ article provides more of the technical details.


JavaOne: Garbage First
Sun's HotSpot Garbage Collectors can be divided into two categories: The young generation and the tenured generation. The majority of allocations will be done in the young generation, which is optimized to have a short lifetime relative to the interval between collections. Objects that survive several collections in the young generation get moved to the tenured generation, which is typically larger and collected less often. The young generation collectors are Serial, ParNew and Parallel Scavenge. All three are stop-the-world copying collectors. Serial uses a single GC thread, whilst ParNew and Parallel Scavenge both use multiple threads. The tenured collectors all use a mark-sweep-compact algorithm. Again three are currently in use: Serial Old, which is another single GC thread, Parallel Old which using multiple GC threads and CMS, a mostly concurrent low pause collector. Garbage First aims to replace CMS and takes a somewhat different approach, straddling the young generation - tenured generation boundary.


JUnit and EasyMock
Unit testing and test driven development are proven ways to improve both the productivity of a developer and the quality of their software. JUnit and EasyMock are the predominant choices for testing tools in the Java space. This reference card will guide you through the creation of unit tests with JUnit and EasyMock. It contains detailed definitions for unit testing and mock objects as well as a description of the lifecycle of each. The APIs for both JUnit and EasyMock are covered thoroughly so you can utilize these tools to their fullest extent.