vendredi 2 mai 2008

Veille technologique semaine 17 et 18

Je vous propose, pour les semaines 17 et 18 les quelques articles suivants :
  • l'art de la séparation des préoccupations : article très théorique,
  • les dix commandements des tests unitaires,
  • la troisième partie sur les EJB 3.1 : l'asynchronisme des services,
  • comment transformer une méthode en objet : les closures,
  • un premier article sur la réalisation d'application multi-threadé en Java pour exploiter les multi-cores,
  • un complément au noyau 2.6.25 de la supervision des threads temps réel,
  • l'instrumentation des classe par un agent pour réaliser du tissage de code pour faire de la programmation par aspects (AOP) pour les trace de log,
  • la sortie de NetBeans 6.1 en version finale

Bonne lecture.

The Art of Separation of Concerns
In software engineering, Separation of Concerns refers to the establishment of
logical boundaries to define and delineate purpose. This improves the ability to
manage and maintain systems by providing order and elegance to the form and
function of system design.
The goal of this article is to promote the understanding of Separation of
Concerns and to establish a set of foundational concepts useful to developers and
architects toward its application.

The Value of Separation
Applying the principle of Separation of Concerns can increase the stability,
maintainability, extensibility, reusability, adoption
, and even the logical and
aesthetic design and flow of a system.

Les 10 commandements des tests unitaires
Les tests unitaires ne sont pas qu'une bonne pratique des méthodes agiles, ils sont un véritable pré-requis à la mise en place d'un développement itératif.

Le refactoring et la modification d'une base de code existante, bien que facilités par les environnements de développement actuels, comportent un évident risque de régression, en partie couvert par les tests unitaires.

Vous trouverez ci-dessous nos 10 commandements des tests unitaires.

New Features in EJB 3.1 part III
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.

  • Asynchronous Invocation of Session Beans
  • EJB Lite is Here
  • Features Still on the Table

First-class methods: Java-style closures
In Java, the method is the principal construct where application logic resides. At present, a method can only exist within a class and cannot be manipulated or referenced in any simple manner.

Other languages permit a block of application logic to be referenced outside of a class, and this is often referred to as a function or a closure. A Java developer can approach the power of functions/closures using two techniques - reflection and inner classes. However, neither is very developer friendly - reflection is not compile-time safe or refactorable, and inner classes are very verbose.

As a result of the difficulty of writing code using reflection and inner classes the techniques tend to be limited to callbacks between an application and a framework. However, the majority of uses of functions or closures in other languages is for small-scale code re-use. This typically involves refactoring out common sections of code which may have a common beginning and end, but different code in the middle. In this scenario, the extracted code isn't run at a much later time like a callback is, but immediately as the original code would have done.

Building Multi-core Ready Java Applications, Part I
With the advent of multi-core processors, the existing subject of symmetric multiprocessing has been thrust to the forefront in the development community. As multi-core CPUs make parallel processing systems more prevalent, and more affordable, there is an increasing need for frameworks that help to handle threading, synchronization, deadlock detection, memory management, data pipelining, vertical/horizontal data partitioning, and so on.

This two-part article series will discuss some of the special design, development and testing techniques that must be used to take full advantage of multiprocessor systems. It examines some frameworks available to make Java-based parallel programming easier and even transparent in some cases.

Finally, Secure Real-Time on the Desktop
Real-Time Group Scheduling, a feature which allows to limit the amount of CPU time real-time processes and threads may consume.

Traditionally on Linux real-time scheduling was limited to priviliged processes, because RT processes can lock up the machine if they enter a busy loop. Scheduling is effectively disabled for them -- they can do whatever they want and are (almost) never preempted by the kernel in what they are doing.

Add Logging at Class Load Time with Java Instrumentation
When trying to analyze why a program failed, a very valuable piece of information is what the program was actually doing at that time. In many cases this can be determined with a stack trace, but frequently that information is not available, or perhaps what you need is information about the data which was being processed at the time of failure.

Traditionally this means using a logging framework like log4j or Java Logging API, and then writing and maintaining all necessary log statements manually. This is very tedious and error prone and well-suited for automation. Java 5 added the Java Instrumentation mechanism which allows you to provide "java agents" which can inspect and modify the byte code of the classes as they are loaded.

This article will show how to implement such a java agent which transparently will add entry and exit logging to all methods in all your classes with the standard Java Logging API. The example used is Hello World:

NetBeans 6.1 released
The NetBeans community has announced the final release of NetBeans 6.1, now available for download:

"NetBeans IDE 6.1 supports a wide range of open source scripting technologies and offers improved performance. This release extends language support beyond Java technology by providing a rich set of features for C/C++, JavaScript and the Ruby language, including Ruby on Rails.

One of the downloads available is an Early Access preview of support for PHP. Advance versions of new modules, such as JavaScript debugger, support of ClearCase, AXIS, and Hibernate are available as separate plugins.

NetBeans IDE 6.1 also contains all of the improvements made in 6.0 including: the new smarter editor, next generation of the ground-breaking GUI builder (formerly known as Project Matisse), visual mobile designer, integrated profiler, and Java EE 5 support.