vendredi 14 mars 2008

Veille technologique semaine 11

Je vous propose pour cette semaine, les quelques articles suivants :
  • Comment la programmation par aspect et le développement centré sur le modèle peuvent être complémentaire ? Comment la séparation des préoccupations peut elle être faite correctement ?
  • Les types nullable de C#
  • Les garbages collectors générationel du JDK 6 et ceux du JDK 7 : garbage first
  • Java et le temps réel pour les applications d'entreprises
  • La suite des nouvelles fonctionnalités des EJB 3.1 : les times services, le packaging
  • Les super package du JDK 7 : gestion plus souple des visibilités des classes et des méthodes.
  • l'outil de visualisation de l'activité d'une JVM : VisualVM, plug-in de la jconsole du JDK 6.

Bonne lecture.

Cross-Cutting Concerns in Model-Driven Software Development
Aspect Oriented Programming (AOP) as well as Model-Driven Software Development (MDSD) are both becoming more and more important in modern software engineering. Both approaches attack important problems of traditional software development. AOP addresses the modularization (and thus, reuse) of cross-cutting concerns (CCC). MDSD allows developers to express structures and algorithms in a more problem-domain oriented language, and automates many of the tedious aspects of software development.

How can cross-cutting concerns be handled effectively in an MDSD based development environment?

Working with Nullable Types in C#
Use nullable types to assign null values to value types(primitives) and avoid run-time exceptions in your applications.
Working with value types was sometimes awkward in .NET 1.x, because they could cause serious problems in applications that retrieved data from database tables containing columns that can have null values—those that may or may not hold data. C# 2.0 presents a new concept called "nullable types" that lets you initialize value types to null values. This article discusses how you can apply the new nullable types feature to solve issues that result from having null values in database columns.

GC générationnels traditionnels (jdk6) VS GC Garbage First (jdk7)
L'analyse empirique montre que dans une application la très grande majorité des objets créés sont détruits presque immédiatement. Les Garbage Collector qui utilisent des implémentations basées sur ce principe sont appelés GC générationnels. On peut fixer deux catégories d'objectifs lorsque l'on optimise le GC : réduire les pauses ou augmenter le débit. Ces objectifs sont en général orthogonaux (la réduction de la durée des pauses se fait au détriment du débit, et vice-versa), ils dépendent souvent du type d'applications : dans une application interactive, nous privilégierons les pauses, et au contraire, dans un batch, seul le débit compte.

La suite du billet est décomposée en deux parties :

  • La première décrit le fonctionnement des algorithmes générationnels traditionnels (Implémentation actuelle des JVM Sun)
  • La seconde détaille le nouvel algorithme que Sun essaye de pousser pour sa future JVM

Real-Time Java for the Enterprise
When people hear about real-time computing they often make the mistake of thinking that these have to be fast systems and are nearly always used for control of mechanical systems. It is true that in most cases the response times required are fast, but speed is not what defines a real-time system. The true core of a real-time environment is that the system will guarantee to perform some task within a pre-defined time so that the system's behaviour becomes fully deterministic.

New features in EJB 3.1 part 2
This series of articles is a preview of the changes the EJB 3.1 expert group is working on for the next version of the Java EE specification. The idea is to give you a head's up on the changes as well as gather your feedback early so the expert group has the best chance of getting it right. EJB 3.0 brought simplicity to Java EE 5 by moving away from a heavyweight programming model. EJB 3.1 aims to build on those successes by moving further down the path of simplicity as well as adding a handful of much-needed features. In each article in this series, I will let you know about the progress made by the expert group.

The Open Road: Superpackages
Since Java 1.0, packages have offered a convenient means of organizing code into different namespaces at the source code level. Classes in the same package can see non-public, non-protected, and non-private methods and fields in other classes in the same package that classes in other packages cannot see.

Unfortunately, there's no standard adjective for members that have no explicit access specifier. The most common, though by no means standard, name for these fields and methods seems to be "default" access. They're also sometimes referred to as "package protected" or "package private." The Java Language Specification uses "default (package)," and that is what I'll use in this article.

What's VisualVM?
VisualVM is a visual tool that integrates several existing JDK software tools and lightweight memory and CPU profiling capabilities. This tool is designed for both production and development time use and further enhances the capability of monitoring and performance analysis for the Java SE platform.

We would like to announce the availability of the VisualVM Beta.

Key news in Beta:

  • Applications defined by JMX connection
  • Application snapshots
  • Defined hosts and VM coredumps persistent between VisualVM sessions
  • Save As & Load for thread dumps and heap dumps
  • Autodiscovery of jstatd started after defining remote host
  • Improved support for JRockit VMs
  • New icons
  • Main menu & toolbar cleanup
  • New icons
  • Customizable Options
  • GlassFish plugin on VisualVM Beta Plugin Center

VisualVM is an open-source Java VM monitoring and performance reporting tool that provides visual feedback about running Java applications. The project released its first beta version on Visualizing characteristics of a running Java application was pioneered by BEA's JRockit virtual machine, which was followed by a large array of monitoring and performance reporting tools, such as jconsole, jstack, or jinfo.

Each of these tools was designed to provide feedback on a specific subset of application execution characteristics, requiring developers to employ multiple tools to get a complete picture of a Java application's execution. At the same time, none of those tools provide a detailed picture of how well an application actually performs.

VisualVM, a new open-source tool developed on, aims to unify many of the capabilities present in earlier tools, and amend those with performance reporting as well. VisualVM can be used during development, and even on a production application, according to the project's documentation, as the tool can be attached to any running Java application:

VisualVM is a tool that provides detailed information about Java applications while they are running. It provides an intuitive graphical user interface that allows you to easily see information about multiple Java applications. Java applications are run by a Java Virtual Machine, or VM. The name VisualVM comes from the fact that VisualVM provides VM information visually.

There are many new features in this release: applications defined by JMX connection, application snapshots, defined hosts and VM coredumps persistence, Load & Save As for thread dumps and heap dumps, autodiscovery of jstatd started after defining remote host, improved support for JRockit VMs, new icons, main menu & toolbar cleanup, customizable Options, GlassFish plugin on Plugin Center.