All the colors of Java and so on

Use Spring 3 Expression Language (spEL) to get an Integer from an environment variable

2012-01-17T18:28:00.003+01:00

Today, I played with Spring Batch. As you probably know, in a classic XML Spring config file, you can use ${my.property} to inject a system property in a bean attribute. That's quite simple.

But, in a JPA item reader (Spring Batch users should understand that), you cannot use this old syntax to inject values in your HQL query (using a parameterValues property). So, I decided to test the fabulously complicated spEL. A wonderful idea...

So, my problem is to get an Integer value from an argument passed to my JVM with something -Dmy.prop=value. Of course, if I don't have any JVM param, I want to have a default value.

Here is the solution :

#{(T(java.lang.Integer).parseInt(systemProperties['process.past.days']?:0))}

So, let's explain it :

#{(systemProperties['process.past.days'])} is required to retrieve a system property called process.past.days
#{(systemProperties['process.past.days']?:0)} is required if you want to set 0 as default value... but... it's horrible... system properties are Strings!!! So, let's parse it.
#{(T(java.lang.Integer).parseInt(...))} is required to convert your String to an Integer

Waoooh! I did it!

My conclusion is that spEL is powerfull but too complicated. How could we maintain that in a few months or years?

Colorify your Eclipse

2011-12-31T09:41:00.002+01:00

Yesterday, while I was watching a video about the Play! framework, I realized that I was contemplating TextMate's colors. So, after some googlings, I discovered a "color plugin" which changes the text theme (it doesn't concern the overall look and feel but just the text apparence here). It is so nice so I put here the update-site url :

http://eclipse-color-theme.github.com/update

Spring saved my day on an UTF-8 encoding problem

2011-12-14T17:21:00.003+01:00

I'm working on Jasig CAS (an SSO server) and I had an issue with special chars. For example, it was impossible to log in with a password like &é"'(-.

I checked my jsp file :it was encoded in UTF-8
I checked the encoding directive (<%@ page contentType="text/html; charset=UTF-8" %>) : OK

The idea was to force the request encoding with something like :

request.setCharacterEncoding("UTF-8");

But I was in Spring MVC and I didn't want an ugly hack. Fortunately, Spring saved my day with a builtin servlet filter to declare in the web.xml.

<filter>
<filter-name>characterEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
<init-param>
<param-name>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>

<filter-mapping>
<filter-name>characterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

Ubuntu 11.10 with classic gnome shell (like gnome 2)

2011-11-18T16:41:00.002+01:00

I discovered that there's a port of gnome indicator applet which allows to have Ubuntu 11.10 with a gnome 3 which looks like gnome 2. It could be nice if you don't like gnome-shell.

http://www.webupd8.org/2011/11/indicator-applet-ported-to-gnome-3-can.html

Common Linux shell commands

2011-11-16T17:54:00.001+01:00

Terminal Cheat Sheet V5

Kill Oracle session after a JVM was killed

2011-11-10T11:53:00.002+01:00

For the moment, I'm playing with Spring Batch. In development, it appends that I need to kill my JVM. The problem is that C3P0 is not allowed to acquire another connection on Oracle on next restart. It's just because the previous one is still there. If you have an Oracle account with the required privileges, the you can see your old session in v$session and destroy it :

select * from v$session
alter system kill session 'sid,serial#'

Ubuntu 11.10 : how to disable the startup sound

2011-11-01T08:30:00.001+01:00

The quickest way is to simply rename the login sound file from a terminal :

mv /usr/share/sounds/ubuntu/stereo/desktop-login.ogg /usr/share/sounds/ubuntu/stereo/desktop-login.ogg.disabled

Ubuntu 11.10 : install OpenJDK

2011-10-30T01:16:00.002+02:00

Open a terminal (Ctrl+Alt+T) and execute the following command ;

sudo apt-get install openjdk-7-jdk

Ubuntu 11.10 and ATI radeon problem : fan always on

2011-10-27T23:00:00.005+02:00

Since I migrated my laptop (HP 4720s) to Ubuntu 11.10 with gnome-shell, I have the following issue :

the open source ATI drivers works well but my fan is always spinning
the additional drivers proposed by Ubuntu don't work and make gnome-shell unusable
the drivers (11.9) from AMD is very slow

So, for the moment, the best deal for me is to keep the open source drivers. DON'T INSTALL ANY OTHER DRIVER THAN THE ONCE INSTALLED BY DEFAULT. What we will do is to underclock the GPU to keep the temperature acceptable and avoid any problems with the fan. Let's open a terminal :

echo -e '#!/bin/sh\necho low > /sys/class/drm/card0/device/power_profile' | sudo tee /etc/init.d/ati-power-save
sudo chmod +x /etc/init.d/ati-power-save
sudo update-rc.d ati-power-save defaults 99

By the way, we will increase FPS by disabling vertical sync.

echo 'export vblank_mode=0' | sudo tee -a /etc/environment

Reboot and enjoy the silence!

Ubuntu 11.10 : you should try gnome-shell

2011-10-21T23:37:00.005+02:00

Ubuntu 11.10 is provided with Unity, the graphical user interface from Canonical. Compared to the previous release (Ubuntu 11.04), you can now swith to Gnome Shell. But, why should you swith from Unity to Gnome Shell that you could consider as very similar? My opinion is that Gnome Shell is more pragmatic and beautiful than Unity.

So, how to activate Gnome Shell ?

Go to the software center and activate the patner repositories in the software sources
In a terminal, run sudo apt-get install gnome-shell
Activate it by default with sudo /usr/lib/lightdm/lightdm-set-defaults -s gnome-shell
Reboot and enjoy!

Now that you have almost a prefect shell, you should install some addons :

sudo apt-get install ubuntu-restricted-extras (for flash, java and dvd features)
enable dvd decryption with sudo sh /usr/share/doc/libdvdread4/install-css.sh
sudo apt-get update
sudo apt-get install chromium-browser
sudo apt-get remove firefox
sudo apt-get install smplayer

A good thing is also to enable numlock on lightdm :

sudo apt-get install numlockx
echo 'greeter-setup-script=/usr/bin/numlockx on' | sudo tee -a /etc/lightdm/lightdm.conf

That's all for my default config.

Another Software Crasftmen Club

2011-09-13T10:31:00.001+02:00

I found it today and I read some interesting stuffs about SCRUM and software development :

http://elegantcode.com/

PL/SQL interroperability

2011-09-12T11:02:00.004+02:00

My company uses an ERP mainly developed in PL/SQL. And we need to deal with external systems. Today, I found a project. It could really help :

http://code.google.com/p/plsql-utils/

Java Persistence Performance Blog

2011-07-12T17:18:00.001+02:00

I found this today : http://java-persistence-performance.blogspot.com/. It has some good tips about JPA tuning.

Recover your disk after a WUBI crash

2011-05-30T11:29:00.002+02:00

This is what I had today. After some two weeks long holidays, my Ubuntu distrib installed with WUBI refused to start. This is the solution I found to get back my files :

sudo fdisk -l
sudo mkdir /win
sudo mount /dev/sdxy /win
sudo mkdir /vdisk
sudo mount -o loop /win/ubuntu/disks/root.disk /vdisk

(Source : http://neosmart.net/forums/showthread.php?t=5004)

A Java VNC Server implementation

2011-05-14T19:42:00.002+02:00

I found this code today and I really have to test it.

Sources are here : http://ramshacking.blogspot.com/2009/07/server-class-for-vnc.html


import java.awt.AWTException;
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.Robot;
import java.awt.Toolkit;
import java.awt.image.BufferedImage;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.ObjectOutputStream;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import javax.swing.ImageIcon;
import javax.swing.JOptionPane;
import java.awt.event.*;

public class JVNCserver{

private final int WIDTH = Toolkit.getDefaultToolkit().getScreenSize().width;
private final int HEIGHT = Toolkit.getDefaultToolkit().getScreenSize().height;
private final Rectangle screenRect = new Rectangle(0, 0, WIDTH, HEIGHT);
public Socket socket;
public ServerSocket s;
private CaptureThread capturethread;
private CaptureEvents captureevents;
private Robot robot;
private ObjectOutputStream out;
private BufferedReader in;
private BufferedImage i;
Image image;

public static void main(String arg[])
{
JVNCserver s = new JVNCserver();
}

public JVNCserver()
{
try
{
s = new ServerSocket(1166);
socket = s.accept();
System.out.println("Server Started");
out = new ObjectOutputStream(socket.getOutputStream());
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
robot = new Robot();
capturethread = new CaptureThread();
captureevents = new CaptureEvents();
}

catch(Exception e)
{
JOptionPane.showMessageDialog(null,"server is stop");
}
}

public void sendImage() throws IOException
{
i = robot.createScreenCapture(screenRect);
image = i.getScaledInstance(WIDTH, HEIGHT-60, Image.SCALE_SMOOTH); out.writeObject(new ImageIcon(image));
i.flush();
image.flush();
out.flush();
}

private class CaptureThread implements Runnable
{
private volatile boolean keepRunning;
Thread thread;
CaptureThread()
{
thread = new Thread(this,"Capture Thread");
keepRunning = true;
thread.start();
}
public void run()
{
while (keepRunning)
{
try
{
sendImage();
Thread.currentThread().sleep(8000);
//Thread.currentThread().sleep(20000);
}
catch(InterruptedException e1)
{ System.out.println("Thread Stop"); }
catch (IOException ex) { ex.printStackTrace(); }
catch(Exception e) {
JOptionPane.showMessageDialog(null,"server is stoped"); } } }
public void stopRunning() { keepRunning = false; } }

private class CaptureEvents implements Runnable {
private volatile boolean keepRunning;
Thread thread;
private int HY = HEIGHT / 2;
int y;
CaptureEvents()
{
thread = new Thread(this,"Capture Events");
keepRunning = true;
thread.start();
}
public void run()
{
while (keepRunning)
{
try
{
if (in!=null)
{
String e = (String)in.readLine();
if (e!=null)
{ //System.out.println(e);
int eventType = Integer.parseInt(e.substring(0, e.indexOf("")));
int arg1 = Integer.parseInt(e.substring(e.indexOf("")+1, e.lastIndexOf("")));
int arg2 = Integer.parseInt(e.substring(e.lastIndexOf("")+1));
//System.out.println(arg1+"-"+arg2);
if(eventType==JVNCconstant.CLOSE) { keepRunning = false; in.close(); out.close(); return; }
if(arg2 < y =" arg2"> HY) y = arg2 + 21;
if (eventType == JVNCconstant.MOUSE_MOVE) robot.mouseMove(arg1,y);
else if (eventType == JVNCconstant.MOUSE_PRESS)
{ robot.mousePress(InputEvent.BUTTON1_MASK); }
else if (eventType==JVNCconstant.MOUSE_RELEASE) robot.mouseRelease(InputEvent.BUTTON1_MASK);
else if(eventType== JVNCconstant.MOUSE_WHEEL) robot.mouseWheel(arg1);
else if(eventType == JVNCconstant.KEY_PRESS_EVENTS)
{
switch(arg1)
{
case KeyEvent.VK_ENTER: robot.keyPress(KeyEvent.VK_ENTER); break;
case KeyEvent.VK_F1: robot.keyPress(KeyEvent.VK_F1); break;
case KeyEvent.VK_ESCAPE: robot.keyPress(KeyEvent.VK_ESCAPE); break; } } } }
else
System.out.println("In empty"); //Thread.currentThread().sleep(50); } /*catch(InterruptedException e) { System.out.println("Thread Stop"); }*/ catch(SocketException ex) { ex.printStackTrace(); JOptionPane.showMessageDialog(null,"Client is stopped"); break; } catch (IOException ex) { ex.printStackTrace(); } catch(Exception e) { JOptionPane.showMessageDialog(null,"Server is stop"); } } } public void stopRunning() { keepRunning = false; } }
}

VMWare is not the only one to virtualize desktops

2011-04-26T11:07:00.007+02:00

Today, as I was looking for some information about Ubuntu 11.04, I discovered Edubuntu weblive. This solution allows to open a real linux session over internet. Just go here and enjoy this revolution : http://www.edubuntu.org/weblive

By the way, I had to understand what kind of technology there is under weblive. I first found Stephane Graber's blog : http://www.stgraber.org. Then, I understood that it's a Linux terminal server with a FreeNX java agent. I realized how it is a real concurrent of the vmware solution.

If (like me), you want to "virtualize" desktops in your company, you have to :

understand how LTSP Cluster works (https://www.ltsp-cluster.org)
understand what is LTSP of course (http://ltsp.org/)
know things about the open source freenx implementation (http://code.google.com/p/neatx/)
have a look to this lauchpad link : https://launchpad.net/~weblive-dev
understand what is LXC (http://lxc.sourceforge.net/)

If you have legacy Microsoft applications such as Outlook, Office or specific IE webapps, there's a video showing an integration sample :

If you want to see who implemented LSTP, go here : http://sourceforge.net/apps/mediawiki/ltsp/index.php?title=Ltsp_SuccessStories

A french article to understand JGroups

2011-03-03T19:39:00.004+01:00

As I had some troubles while I was integrating an eh-cache distributed by jgroups, I found this :

http://jetoile.blogspot.com/2010/12/jgroups-tour-d.html

Maven war overlay and debugging

2011-02-21T11:00:00.005+01:00

I'm currently working on a project which uses the maven war overlay feature. In such condition, I didn't succeed to start my a Tomcat instance from Eclipse WTP. That's because the war is built to late in the maven process and the Maven integration with WTP never calls the appropriate building step. Thus, I decided to start my server from the command line. With 'war overlay', I need to do :

mvn tomcat:run-war

But, what about debugging? Here I found two solutions.

Solution 1 : the standard mode

Just use :

mvnDebug tomcat:run-war

But it's a pre-configured solution and you should want to precise some specific options according to your environment.

Solution 2 : customize your debugging options

This is very simple.

Ensure that you correctly declared your JAVA_HOME
Set the debugging options which will be used by the JVM

For example :

export MAVEN_OPTS="-Xdebug -Xnoagent -Djava.compiler=NONE -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000"

Then, just start your server with mvn tomcat:run-war

High-Performance Oracle JDBC Programming

2010-12-21T11:53:00.007+01:00

IMPORTANT NOTE : I'm not the author of this post. Ths original location is here : http://blog.csdn.net/hakunamatata2008/archive/2009/05/13/4175764.aspx

High-Performance Oracle JDBC Programming

Learn how to improve performance of Oracle-driven JDBC programs by leveraging connection and statement pooling features.

By Yuli Vasiliev

Published April 2009

Using pooling techniques such as connection pooling and statement pooling can significantly improve performance of database-intensive applications, because it enables the reuse of objects that would otherwise need to be created from scratch, at the expense of time and resources.

Reusing database connection objects representing physical database connections utilized by an application can result in significant performance gains, provided that the application interacts with the database intensively, frequently re-establishing connections with the same parameters. On the other hand, you won’t benefit from using a connection pool if your application connects to its underlying database only rarely. In practice, though, many database-intensive applications can benefit from utilizing a connection pool, provided that the pool’s settings, such as those that put a limit on the maximum and minimum number of connections allowed, are optimized for that particular application.

Like connection pooling, statement pooling is a technique for improving application performance. You can achieve additional performance gains by pooling statements that are executed multiple times in the course of a run of your program. It’s important to realize, though, that statement pooling is not a silver bullet for performance problems. If you cache every single statement without distinguishing how many times it is executed in your program, you are unlikely to achieve any performance improvement. In fact, caching the statements that are issued only once during program execution may actually degrade performance, due to the overhead associated with putting and then keeping such statements in the cache.

This article shows you how to take advantage of pooling connections and statements to improve performance of data-intensive Java DataBase Connectivity (JDBC) programs interacting with Oracle Database via the Oracle JDBC thin driver. In particular, it looks at the Oracle Universal Connection Pool (UCP) for JDBC, which provides a full-featured connection pool implementation for caching JDBC connections. Finally it discusses how you might benefit from statement pooling, utilizing features specific to Oracle’s JDBC drivers as well as the new JDBC 4.0 methods added to the Statement interface and available in Oracle JDBC drivers supporting Java Development Kit (JDK) 1.6 and later versions.
Setting Up Your Working Environment

To follow the examples in this article, in addition to having access to an Oracle database, you’ll need to have the following software components installed on your development machine (see "Downloads" portlet for links:

JDK 1.6
Oracle JDBC thin driver supporting JDK 1.6
Oracle Universal Connection Pool library

The Oracle JDBC thin driver is a Type IV JDBC driver, meaning that it’s platform-independent and does not require any extra Oracle software on the client side to interact with an Oracle database. So you can download the JAR file containing the classes of an appropriate thin driver version from the JDBC Driver Downloads page and then install the driver on your machine without having to install/upgrade any other Oracle software. To install the driver, you simply need to copy its JAR files to your local file system and then include paths to these JARs to the CLASSPATH environment variable. For example, you might include the following paths:

ORACLE_HOME/jdbc/lib/ojdbc6.jar
ORACLE_HOME/jlib/orai18n.jar

If you have an Oracle database installed on your machine, the thin driver has been installed with your Oracle Database installation. However, because the thin driver does not depend on any additional Oracle software, you can easily upgrade to the latest release of the driver by using appropriate JAR files that can be found on the JDBC Driver Downloads page.

UCPis a new feature included in Oracle Database 11g, starting with release 11.1.0.7. This feature is also available in Oracle Application Server, beginning with Oracle Application Server 11gRelease 1. If you’re using older software that doesn’t ship the JAR file for UCP(it’s called ucp.jar) or you want to upgrade to the latest UCPrelease, you can pick up ucp.jar from the Oracle Database UCP Downloads page. This package contains UCP’s classes for inclusion in the classpath to enable the feature. The path included might look like this:

ORACLE_HOME/ucp/lib/ucp.jar

Caching JDBC Connections with UCP

If you’re developing a database-intensive application, you might benefit from using a connection pool, which enables you to reuse connections rather than create a new one each time it is requested. Connection pooling conserves resources required for creating new database connections and improves your application performance, because creating a new connection is always a performance-intensive operation.

The Oracle Universal Connection Pool for JDBC represents a full-featured implementation of a connection pool caching JDBC connections. UCP is a very useful feature, in that it lets you reuse connection objects, thus speeding the process of obtaining a connection and saving resources associated with opening new database connections.

Suppose you want to create aUCP JDBC connection pool to reuse connections established to the HR/HR Oracle Database sample schema. The following program, representing a simple example of aUCP JDBC connection pool in action, shows how you might achieve this. Here you first create a pool-enabled data source instance and then set up the connection and pool properties. Once you’ve done that, you borrow a connection from the pool and then use that connection to interact with the database. Finally, you close the connection, returning it to the pool.

/*
*A simple example illustrating aUCP JDBC connection in action
*/
import java.sql.*;
import oracle.ucp.jdbc.PoolDataSourceFactory;
import oracle.ucp.jdbc.PoolDataSource;

public class UcpConnection {
public static void main(String args[]) throws SQLException {
try
{
//Creating a pool-enabled data source
PoolDataSource pds = PoolDataSourceFactory.getPoolDataSource();
//Setting connection properties of the data source
pds.setConnectionFactoryClassName("oracle.jdbc.pool.OracleDataSource");
pds.setURL("jdbc:oracle:thin:@//localhost:1521/XE");
pds.setUser("hr");
pds.setPassword("hr");
//Setting pool properties
pds.setInitialPoolSize(5);
pds.setMinPoolSize(5);
pds.setMaxPoolSize(10);
//Borrowing a connection from the pool
Connection conn = pds.getConnection();
System.out.println("\nConnection borrowed from the pool");
//Checking the number of available and borrowed connections
int avlConnCount = pds.getAvailableConnectionsCount();
System.out.println("\nAvailable connections: " + avlConnCount);
int brwConnCount = pds.getBorrowedConnectionsCount();
System.out.println("\nBorrowed connections: " + brwConnCount);
//Working with the connection
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("select user from dual");
while(rs.next())
System.out.println("\nConnected as: "+rs.getString(1));
rs.close();
//Returning the connection to the pool
conn.close();
conn=null;
System.out.println("\nConnection returned to the pool");
//Checking the number of available and borrowed connections again
avlConnCount = pds.getAvailableConnectionsCount();
System.out.println("\nAvailable connections: " + avlConnCount);
brwConnCount = pds.getBorrowedConnectionsCount();
System.out.println("\nBorrowed connections: " + brwConnCount);
}
catch(SQLException e)
{
System.out.println("\nAn SQL exception occurred : " + e.getMessage());
}
}
}

An important thing to notice here is what’s happening when a connection is closed. The output of the above program illustrates that closing a connection borrowed from a UCP JDBC connection pool actually returns that connection to the pool, where it becomes available for the next connection request.

Here is what the program output should look like:

Connection borrowed from the pool
Available connections: 4
Borrowed connections: 1
Connected as: HR
Connection returned to the pool
Available connections: 5
Borrowed connections: 0

Borrowing a Connection with JNDI

Instead of creating a pool-enabled data source on the fly, as you did in the preceding example, you can create it in advance and bind it to a Java Naming and Directory Interface (JNDI) context and a logical name. Once you’ve registered a data source with JNDI, you can get an instance of it by performing a JNDI lookup, specifying the JNDI name to which the data source is bound.

Suppose you want to register a pool-enabled data source designed to reuse connections to the HR/HR database schema, associating this data source with logical name jdbc/HRPool in the JNDI tree. To do this, you must create a PoolDataSource object representing the above data source, set its properties, and then register it with a JNDI naming service. This can be done with the following Java program:

/*
*An example of how you can register
* a pool-enabled data source with JNDI
*/
import oracle.ucp.jdbc.PoolDataSourceFactory;
import oracle.ucp.jdbc.PoolDataSource;
import javax.naming.*;
import java.util.Hashtable;

public class JNDIRegister {
public static void main(String argv[]) {
try {
//Creating a pool-enabled data source instance and setting its properties
PoolDataSource pds = PoolDataSourceFactory.getPoolDataSource();
pds.setConnectionFactoryClassName("oracle.jdbc.pool.OracleDataSource");
pds.setURL("jdbc:oracle:thin:@//localhost:1521/XE");
pds.setUser("hr");
pds.setPassword("hr");
pds.setInitialPoolSize(5);
pds.setMinPoolSize(5);
pds.setMaxPoolSize(10);
//Registering the data source with JNDI
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY,"com.sun.jndi.fscontext.RefFSContextFactory");
Context ctx = new InitialContext(env);
ctx.bind("jdbc/HRPool", pds);
}
catch (Exception e) {
System.out.println(e);
}
}
}

Before you can run this program, you have to set up Sun's file system JNDI service provider, which can be downloaded from here. Make sure to add the following JAR files to the classpath to be able to run the above program:

install_dir/sun/lib/fs/fscontext.jar;install_dir/sun/lib/fs/providerutil.jar

After you run the above program, you can utilize the jdbc/HRPool pool-enabled data source in your Java applications, whether they be JavaServer Pages, servlets, or standalone applications. The following is a standalone Java application utilizing this data source:

/*
*An example of a JNDI lookup for
* a pool-enabled data source
*/
import java.sql.*;
import oracle.ucp.jdbc.PoolDataSource;
import javax.naming.*;
import java.util.Hashtable;

public class JNDILookup {
public static void main(String argv[]) {
PoolDataSource pds;
//Performing a lookup for a pool-enabled data source registered in JNDI tree
try {
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY,"com.sun.jndi.fscontext.RefFSContextFactory");
Context ctx = new InitialContext(env);
pds = (PoolDataSource) ctx.lookup("jdbc/HRPool");
}
catch (NamingException eName) {
System.out.println("Cannot look up " + "jdbc/HRPool" + ": " +eName);
return;
}
//Borrowing a connection from the data source returned by the JNDI lookup
try {
Connection conn = pds.getConnection();
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("select user from dual");
while(rs.next())
System.out.println("\nConnected as: "+rs.getString(1));
if (conn != null)
conn.close();
}
catch (SQLException eSQL) {
System.out.println("Cannot obtain a connection: " + eSQL);
}
return;
}
}

The first thing you do in the above program is to initialize the JNDI context, which is then used to perform a JNDI lookup for the jdbc/HROracle pool-enabled data source. Next you borrow a connection from the data source instance returned by the JNDI lookup and use it to issue a query against the database.

As you no doubt have realized, the approach discussed in this section simplifies the process of using connection pools. Registering a pool-enabled data source once and then obtaining an instance of it with a JNDI lookup when needed eliminates the need to set up the connection pool properties each time you initialize it. You just obtain a pool instance with the properties defined in advance.
High Availability and Performance

It’s important to emphasize that UCP supports new JDBC 4.0 high-availability and performance features, such as pool refreshing and connection validating, that are not related to Oracle Real Application Clusters (RAC) and therefore do not require an Oracle RAC database.

Validate connection

Furthermore, UCP provides the ability to validate connections on borrow. Validating connections on borrow is a useful technique, because it enables you to check whether a connection is still valid before you start using it. To help with this problem, a UCP JDBC connection pool instance has the ValidateConnectionOnBorrow property of type Boolean, which you need to set to true with the setValidateConnectionOnBorrow method:

pds.setValidateConnectionOnBorrow(true);

Then you need to specify an SQL statement you want to be issued to make sure that the connection is still valid. You can do this with the setSQLForValidateConnection method:

pds.setSQLForValidateConnection("select user from dual");

When utilizing an Oracle JDBC driver, though, there is no need to set the SQLForValidateConnection property—the pool will perform an internal ping to test the validity of the connection being borrowed.

Verifying connections on borrow is a good thing, but what if a connection becomes stale after it has been successfully validated on borrow? Is there any way to verify a connection after it has been borrowed? To address this issue, the JDBC 4.0 specification added the isValid method to the Connection interface, enabling you to test the validity of a connection when you want to.

Taking it one step further, UCP for JDBC provides the oracle.ucp.jdbc.ValidConnection interface, which includes two methods: isValid and setInvalid. These methods can be especially useful when utilized in conjunction with a retry mechanism implemented with recursion or iteration (looping). For instance, you might implement a method that will borrow and then utilize a connection, making a recursive call to itself in case the connection has become stale and consequently the operation cannot be completed. An important thing to keep in mind when implementing such a recursive mechanism is that it must provide the ability to limit the number of recursive calls to be made and that each new recursive call must reduce that number, thus preventing the possibility of endless looping.

The following is a simple program providing an example of how you might use the oracle.ucp.jdbc.ValidConnection interface methods in conjunction with a retry mechanism based on recursion.

/*
*An example of validating connections on borrow;
*this also shows the use of the ValidConnection interface's methods:
*isValid and setInvalid methods in combination with a retry mechanism
*/

import java.sql.*;
import oracle.ucp.jdbc.PoolDataSource;
import oracle.ucp.jdbc.ValidConnection;
import javax.naming.*;
import java.util.Hashtable;

public class ConnectionValidating {
public static void main(String argv[]) {
PoolDataSource pds;
//Looking up for the jdbc/HRPool pool-enabled data source registered in JNDI tree
...
//for actual code see the JNDI lookup example
//discussed in the Borrowing a Connection with JNDI section earlier
...
try {
//Instructing the pool to validate connections on borrow
pds.setValidateConnectionOnBorrow(true);
//Calling the getUser method that borrows a connection from the pool
//limiting the number of recursive calls to 3
System.out.println("\nConnected as :"+getUser(pds, 3));
}
catch (SQLException eSQL) {
System.out.println("\nSQLException: " + eSQL);
return;
}
}
//This method borrows a connection from the pool and will make a recursive call
//if it turns out that the borrowed connection has become unusable
private static String getUser (PoolDataSource pds, int recursiveCalls) throws SQLException {
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
String user = null;
try {
//Borrowing a connection from the pool
conn = pds.getConnection();
//Working with the connection
stmt = conn.createStatement();
rs = stmt.executeQuery("select user from dual");
while(rs.next())
user = rs.getString(1);
if (conn != null)
conn.close();
}
catch (SQLException eSQL) {
if (recursiveCalls > 0 && !((ValidConnection) conn).isValid()) {
System.out.println("\nConnection is no longer valid: " + eSQL);
//Calling setInvalid often leads to an exception
//so it's a wise idea to put it in a separate try block
try {
((ValidConnection) conn).setInvalid();
} catch (SQLException conEx) {
System.out.println("\nInvalidating failed: " + conEx);
}
conn.close();
conn = null;
System.out.println("\nRetrying to obtain a new connection");
//making a recursive call to getUser in an attempt to obtain a valid connection
//the number of recursive calls allowed is reduced by 1
user = getUser(pds, recursiveCalls - 1);
} else {
System.out.println("\nSQLException: " + eSQL);
}
}
finally {
return user;
}
}
}

In this example, the getUser method calls itself from within the catch clause of the try/catch statement implemented in this same method. Here, you limit the number of allowed recursive calls to three. If it fails to obtain a valid connection three times in a row, you stop trying and get out.

High-availability features

Aside from the generic high-availability and performance features discussed above, UCP for JDBC can be integrated with Oracle RAC features such as Fast Connection Failover (FCF) and Runtime Connection Load Balancing, making it easier to manage connections to an Oracle RAC database.

The following snippet illustrates how you can enable FCF when using a UCP JDBC connection pool managing connections to an Oracle RAC database. Note that using FCF requires you to add the Oracle Notification Service library (ons.jar) to an application’s classpath. The Oracle Notification Service library is shipped as part of Oracle Database, starting with Oracle Database 10g.

...
//Creating a pool-enabled data source
PoolDataSource pds = PoolDataSourceFactory.getPoolDataSource();
//Setting pool properties
pds.setConnectionFactoryClassName("oracle.jdbc.pool.OracleDataSource");
//Setting a RAC-specific URL
pds.setURL(
"jdbc:oracle:thin:@" +
"(DESCRIPTION=(ADDRESS_LIST=(LOAD_BALANCE=ON)" +
"(ADDRESS=(PROTOCOL=TCP)" +
"(HOST=rachost1)(PORT=1521))" +
"(ADDRESS=(PROTOCOL=TCP)" +
"(HOST=rachost2)(PORT=1521)))" +
"(CONNECT_DATA=(SERVICE_NAME=orcl)))");
pds.setUser("usr");
pds.setPassword("pswd");
pds.setMinPoolSize(10);
pds.setMaxPoolSize(20);
//Configuring remote ONS subscription
pds.setONSConfiguration("nodes=rachost1:4200,rachost2:4200");
// Enabling Fast Connection Failover
pds.setFastConnectionFailoverEnabled(true);

Once you have a connection pool set up and FCF enabled, you can borrow a connection from the pool and create queries on it as you would in a non- RAC-specific program.

Connection conn = pds.getConnection();
Statement stmt = conn.createStatement();
ResultSet rs = null;

Then you can implement a retry mechanism that will check a connection for validity after a RAC-down event triggers UCP FCF actions, trying again to connect to surviving RAC instances in case the connection has become stale. The following snippet illustrates how this could be implemented within a while loop.

boolean retry = true;
while(retry)
{
try
{
//Getting a RAC connection from the pool
conn = pds.getConnection();
// Executing a query on the connection.
rs = stmt.executeQuery("select user from dual");
rs.next();
System.out.println("\nConnected as : " + rs.getString(1));
//Setting retry to false to exit the loop
retry = false;
}
catch (SQLException eSQL)
{
System.out.println("\nSQLException: " + eSQL);
// Checking connection usability after a RAC-down event triggers UCP FCF actions
if (conn == null || !((ValidConnection) conn).isValid())
{
//Closing the connection
try
{
conn.close();
}
catch (SQLException eClose)
{
System.out.println("\nException arose when closing connection: " + eClose);
}
//Setting retry to true to try again
retry = true;
}
}
Thread.sleep(1000);
}

If a connection has been successfully borrowed from the pool and the statement execution has not triggered an exception, there is no need to retry the operation and therefore the execution flow will jump out of the loop. Otherwise, it will try to reconnect and will then perform the statement execution again.
Optimizing Connection Pools

Optimize pooling behavior with parameters and callbacks

The UCP JDBC connection pool provides a set of properties you can use to optimize pooling behavior. For example, you can regulate the pool size, setting the properties controlling the initial, maximum, and minimum pool size. In the preceding sections, you have seen how you can set up these properties.

Aside from the properties controlling the pool size, there are properties controlling stale connections. For example, you can set up the pool’s MaxConnectionReuseTime property, thus configuring a maximum connection reuse time. In some environments, you may find it useful to have connections removed from the pool after a connection has been borrowed a certain number of times. You can do this by setting up the MaxConnectionReuseCount property.

You can set up the AbandonConnectionTimeout property to instruct the pool to reclaim borrowed connections after a connection has not been used for a certain amount of time. Also, you can set up the TimeToLiveConnectionTimeout property, limiting how long a borrowed connection may be used before it is reclaimed by the pool.

If you anticipate that the pool may run out of connections at some point, you can set the ConnectionWaitTimeout property to the number of seconds an application request waits for a connection when no connections are available in the pool. Also, there is the InactiveConnectionTimeout property, which enables you to specify how long an available connection can remain unborrowed before it is removed from the pool.

Another interesting property is TimeoutCheckInterval, with which you can set up the timeout check interval, controlling how often the timeout properties discussed above will be enforced. By default, this property is set to 30, meaning that the timeout check cycle runs every 30 seconds.

All the optimization features discussed so far in this section require you to set a certain property to an appropriate value in order to get the effect you want, but to enable the connection harvesting feature, which is used to ensure a certain number of available connections in the pool, you need to use a mechanism that’s a bit more complicated. This feature is explained in the rest of this section by example.

Let’s say you set up the pool’s size properties as follows:

...
pds.setInitialPoolSize(10);
pds.setMaxPoolSize(20);

With initialPoolSize set to 10, you will have 10 connections upon initializing the connection pool. Next, with the following code, you enable the connection harvesting feature, thus making the pool’s connections harvestable:

pds.setConnectionHarvestTriggerCount(5);
pds.setConnectionHarvestMaxCount(2);

The properties set above instruct the pool to reclaim two borrowed connections when the number of available connections in the pool drops to five. Let’s now create an array of five connection objects that can be then used to hold five connections borrowed from the pool:

//Creating an array of connection objects
Connection[] conn = new Connection[5];

Before populating the above array with connections, though, you need to create an array of callback objects, each of which will be registered with a connection. A callback object must be an instance of a custom implementation of the ConnectionHarvestingCallback abstract interface. A simple implementation is shown a little later in this section.

With the following code, you create an array of five CustConnectionHarvestingCallback objects:

//Creating an array of callback objects
CustConnectionHarvestingCallback[] callbk = new CustConnectionHarvestingCallback[5];

In the following loop, you borrow four connections from the pool and also create four callback objects, each of which is registered with a connection:

//Borrowing four connections from the pool
for (int i = 0; i <>
{
conn[i] = pds.getConnection();
//Registering the callback object with each connection
callbk[i] = new CustConnectionHarvestingCallback(conn[i]);
((HarvestableConnection) conn[i]).registerConnectionHarvestingCallback(callbk[i]);
}

Before you borrow the fifth connection to trigger harvesting, you can disable harvesting on a certain connection for testing purposes. You might recall that you specified two borrowed connections to be returned to the pool when the number of available connections drops to five. By default, the connection harvest feature will harvest those two connections that were borrowed first. Thus, in this example, conn[0] and conn[1] will be harvested. By setting conn[0] as nonharvestable, however, you make it harvest conn[1] and conn[2].

//Setting conn[0] as nonharvestable
((HarvestableConnection) conn[0]).setConnectionHarvestable(false);

Let’s now trigger harvesting by borrowing the fifth connection from the pool.

//Borrowing the fifth connection to trigger harvesting
conn[4] = pds.getConnection();
callbk[4] = new CustConnectionHarvestingCallback(conn[4]);
((HarvestableConnection) conn[4]).registerConnectionHarvestingCallback(callbk[4]);

Recall from the discussion of the timeout check interval earlier in this section that this interval is set to 30 by default. What this means in this example is that harvesting will not be triggered immediately but within a 30-second interval.

// Waiting for harvesting to happen
Thread.sleep(30000);

To make sure everything has worked as planned, you might want to check through the connections to see which ones have been closed and returned to the pool:

//Checking connections
for (int i = 0; i <>
{
System.out.println("Connection " + i + " returned to the pool - " + conn[i].isClosed());
}

The above should generate output showing that conn[1] and conn[2] have been closed and therefore returned to the pool whereas the other three are still in the borrowed state.

Finally, here is how you might implement the ConnectionHarvestingCallback abstract interface so that its cleanup method closes the connection being harvested:

class CustConnectionHarvestingCallback implements ConnectionHarvestingCallback
{
private Connection conn = null;
public CustConnectionHarvestingCallback(Connection conn)
{
this.conn = conn;
}
public boolean cleanup()
{
try {
conn.close();
}
catch (Exception e) {
return false;
}
return true;
}
}

The above is a simple example of a ConnectionHarvestingCallback abstract interface implementation. In a real-world application, you might want to use a more complicated implementation. In particular, you might need to implement more-complex logic in the cleanup method, such as rolling back the transaction associated with the connection being harvested, before closing that connection.

As you have learned in this section, there are several UCP JDBC connection pool properties you can use to optimize pooling behavior. So, it's often a good idea to experiment with pool settings to find the combination that best fits the needs of your application.

Statement Pooling

This recommendation may seem obvious, but the importance of statement pooling in data-intensive applications cannot be overstated. Oracle JDBC drivers support explicit and implicit statement caching, enabling you to cache prepared and callable statements. Implicit caching doesn’t require you to take any special action to send statements to and retrieve them from a cache—a prepared or callable statement automatically goes to the cache when you invoke the close method of that statement object. The next time you create this statement on this same connection, it will be retrieved from the cache rather than being created from scratch. If implicit caching is turned on, a statement object will be reused from the cache when the following conditions are met:

The SQL string used in the statement is equal to one held in the cache.
The statement type is also the same, meaning prepared or callable.
The scrollable type of the result set generated by the statement is also the same, meaning forward-only or scrollable.

Although Oracle JDBC drivers are designed with the supposition that implicit caching is enabled, this feature is not turned on by default. To enable implicit caching on the connection, you can set the implicitCachingEnabled property of the corresponding OracleConnection object to true and set the statementCacheSize property to a positive integer. This can be done as follows:

conn.setImplicitCachingEnabled(true);
conn.setStatementCacheSize(10);

When using aUCP JDBC connection pool, you can enable statement caching by setting maxStatements property to a positive integer:

pds.setMaxStatements(10);

If you do this, statement caching will be enabled for each connection within the pool. The following program provides a simplified example of how you can use statement pooling, taking advantage of connection pooling at the same time:

/*
*An example of statement pooling in action
*/

import java.sql.*;
import oracle.ucp.jdbc.PoolDataSource;
import oracle.jdbc.OracleConnection;
import oracle.jdbc.OraclePreparedStatement;
import javax.naming.*;
import java.util.Hashtable;

public class StatementPooling {
public static void main(String argv[]) {
PoolDataSource pds;
//Looking up for the jdbc/HRPool pool-enabled data source registered in the JNDI tree
...
//for actual code, see the JNDI lookup example
//discussed in the Borrowing a Connection with JNDI section earlier
...
try {
//Enabling statement caching for the pool's connections
pds.setMaxStatements(10);
//Borrowing a connection from the pool
OracleConnection conn = (OracleConnection) pds.getConnection();
//Checking whether the implicit statement caching is enabled
if (conn.getImplicitCachingEnabled())
System.out.println("\nimplicit caching enabled");
else
System.out.println("\nimplicit caching disabled");
//Looping through calls to the getRegion private class method that executes a prepared statement
for (int i = 1; i <>
System.out.println("\n" + getRegion(conn, i));
}
//Returning the connection to the pool
if (conn != null)
conn.close();
conn = null;
}
catch (SQLException eSQL) {
System.out.println("Cannot obtain a connection: " + eSQL);
}
}
//This method creates, executes, and then closes a prepared statement
private static String getRegion (OracleConnection conn, int region_id ) throws SQLException {
OraclePreparedStatement stmt = null;
ResultSet rs = null;
String region = null;
String sql = "SELECT * FROM regions WHERE region_id = ?";
try {
stmt = (OraclePreparedStatement)conn.prepareStatement(sql);
stmt.setInt(1, region_id);
rs = stmt.executeQuery();
rs.next();
region = rs.getString("REGION_NAME");
}
catch (SQLException eSQL) {
System.out.println("\nSQLException: " + eSQL);
}
//this code is executed under all circumstances
finally {
if (rs != null)
rs.close ();
if (stmt != null)
//if implicit caching is enabled, the statement is not actually closed
//but is sent to the cache
stmt.close ();
return region;
}
}
}

As you can see, the getRegion method of the class shown above creates, executes, and then closes a prepared statement, returning the query result to the calling code. This method is called repeatedly in a loop running in the main method, making implicit statement caching possible. In this example, you enabled implicit caching when you called the setMaxStatements method of the connection pool instance. So calling the close method of the prepared statement in the getRegion method will actually cache the statement instead of closing it, thus letting the program reuse it on the second and subsequent calls to getRegion. To make sure it works as expected, you can add the following code to the getRegion method, putting it right after the call to the prepareStatement method of the OracleConnection object:

...
//Checking the creation state of the prepared statement
int creationState = stmt.creationState();
switch(creationState) {
case 0:
System.out.println("\nCreation state: new");
break;
case 1:
System.out.println("\nCreation state: from the implicit cache");
break;
case 2:
System.out.println("\nCreation state: from the explicit cache");
break;
}
...

If you now execute the program, you should see that the prepared statement’s creation status is new only upon the first call to getRegion—all subsequent getRegion calls reuse the statement cached implicitly.

Being able to enable statement caching for every statement on every connection within the pool is a start, but how you can you apply this technique selectively, disabling caching statements on a certain pooled connection or even disabling caching for a certain statement?

If you recall from the discussion at the beginning of this section, you can use an OracleConnection implicitCachingEnabled property to enable or disable statement caching for that particular connection. For example, you may have enabled statement caching for each connection within the pool and may then disable it on a particular connection as follows:

conn.setImplicitCachingEnabled(false);

As for disabling or enabling caching on particular statements, you can take advantage of the new JDBC 4.0 methods added to the Statement interface. In particular, to make a statement object poolable or not poolable, you can use its setPoolable method, passing in true or false, respectively. To check out the current poolable state of a statement object, you can use the isPoolable method of that object. Here is how you might prevent a particular prepared statement from going to the implicit cache:

if(stmt.isPoolable())
stmt.setPoolable(false);

It’s interesting to note here that if implicit caching is not enabled on the connection, an attempt to enable it for a particular statement with setPoolable(true) won’t force the desired effect. Although the poolable property of a statement object is set to true by default, you still need to first turn implicit caching on for the connection or the entire connection pool, as described at the beginning of this section.

Conclusion

In this article, you learned how to take advantage of connection and statement pooling, utilizing outstanding Oracle-specific JDBC features as well as the standard JDBC 4.0 features. In particular, you looked at the Oracle Universal Connection Pool for JDBC, a new Oracle Database 11g feature providing a connection pool implementation for caching JDBC connections. Then you learned how to take advantage of statement pooling, utilizing features specific to Oracle’s JDBC drivers as well as the new JDBC 4.0 methods added to the Statement interface.

Yuli Vasiliev is a software developer, freelance author, and consultant currently specializing in open source development, Java technologies, databases, and SOA. He is the author of Beginning Database-Driven Application Development in Java EE: Using GlassFish (Apress, 2008).

Replace your C3P0 or DBCP by Oracle pool (UCP)

2010-12-21T10:15:00.032+01:00

Introduction : ODS or UCP?

I've been using DBCP and C3P0 for a long time. But, a few months ago, I started to have problems with them. For example, sometimes, no way to get any connection to my database (while it's still possible with my Oracle SQL Developer). So, I decided to look at the code of C3P0. What a surprise! Even if it's a very common pool for a lot of projects (such as Hibernate), it seems to be dead. No more development, code complicated with sub projects, no Maven integration (...ok, ok, even if you hate Maven, you have to admit that it is very efficient to modify the code of mavenized projects...). Thus, I looked for a new pool. Of course, I found the recent tomcat jdbc pool. But I finally decided to work with Oracle pool just because I only have Oracle databases.

So, this post is my history with Oracle pool.

When you look for pool features on Oracle doc website, you find to ways to implement it :

Oracle DataSource pool (also called ODS) and included in the driver jar file
Oracle Universal Connection Pool (UCP), which is packaged in its own jar file (ucp.jar)

ODS : the old way

First of all, ODS is the old way. Its interfaces are still usable BUT deprecated. See it by yourself by looking at the code of OracleConnectionCacheImpl. This class contains tuning parameters. This a an example of my Spring configuration with ODS :

<bean id="OracleNativePoolParent" class="oracle.jdbc.pool.OracleDataSource"
destroy-method="close" lazy-init="true" >
<property name="user" value="****" />
<property name="password" value="****" />
<property name="serverName" value="****" />
<property name="databaseName" value="****" />
<property name="driverType" value="thin" />
<property name="networkProtocol" value="tcp" />
<property name="portNumber" value="1521" />
<property name="connectionCachingEnabled" value="true" />
<property name="connectionCacheProperties">
<props merge="default">
<prop key="InitialLimit">1</prop>
<prop key="MinLimit">1</prop>
<prop key="MaxLimit">10</prop>
</props>
</property>
<property name="maxStatements" value="400" />
<property name="loginTimeout" value="20" />
<property name="connectionProperties">
<props merge="default">
<prop key="AutoCommit">false</prop>
</props>
</property>
</bean>

UCP : you should use it instead of ODS

Now, let's switch to UCP. Curiously, We need to use a factory to obtain an instance of this pool. This is my Spring configuration :

<bean id="OracleNativePoolParent" class="oracle.ucp.jdbc.PoolDataSourceFactory" factory-method="getPoolDataSource" lazy-init="true" >
<property name="connectionFactoryClassName" value="oracle.jdbc.pool.OracleDataSource"/>
<property name="user" value="****" />
<property name="password" value="****" />
<property name="URL" value="jdbc:oracle:thin:@myServer:1521:myDB" />
<property name="connectionWaitTimeout" value="30" />
<property name="minPoolSize" value="1"/>
<property name="maxPoolSize" value="10"/>
<property name="inactiveConnectionTimeout" value="3600"/>
<property name="validateConnectionOnBorrow" value="true"/>
<property name="maxStatements" value="400"/>
<property name="connectionProperties">
<props merge="default">
<prop key="AutoCommit">false</prop>
</props>
</property>
</bean>

Driver Oracle 11g blocked on startup

While initializing your pool, you have to wait 5 minutes then get an exception? Don't panic. It's just a little but with Sun Java on Linux OS. Add this JVM parameter :

-Djava.security.egd=file:///dev/urandom

More informations here : http://www.usn-it.de/index.php/2009/02/20/oracle-11g-jdbc-driver-hangs-blocked-by-devrandom-entropy-pool-empty/

Conclusion

Even if I didn't find all the options I had with C3P0, UCP seems to be efficient for me. I think that it's a best choice to work with Oracle database because it is officially supported. But, there's still a negative point. As I don't have the source code, it will be very difficult to qualify bugs and to understand advanced parameters (and I think that the official documentation is not exhaustive at all).

My new best business site

2010-09-10T14:26:00.003+02:00

I found it while I was surfing on the JDuchess french site. This site (and of course its author) aims to give the keys to self-teaching of the art of business.

Thanks to Mathilde Lemée (http://www.java-freelance.fr/)

http://personalmba.com/best-business-books/

My AJP connector is sick!!!

2010-09-09T11:55:00.003+02:00

Today, I had a problem between my Apache balancer and my Tomcat cluster. A virtual machine that was hosting two Tomcats was frozen. Something was wrong in my config and the Apache didn't show these Tomcats in error in the jk_status web interface. After a few minutes, I realized that the uriworkermap file was not configure on 'balancer' but directly on 'tomcat1' (one of the two Tomcats that were down).

So, I concluded that the Apache jk doesn't do any test on a worker if it isn't mapped with an uri.

But let'go back to my virtual machine that was frozen. It was not completely dead and a telnet 8010 was responding. Thus, my first conclusion was that I had a problem with my Apache. BAD WAY!!! The telnet was not efficient. I demonstrated that with a tiny perl script found on the net made to simulate an ajp ping.

You can use the script as this : time ./ajp_ping.pl server:8009

Many thanks to the author of this script. I don't have the link to his post anymore.

Here is the script content :

#!/usr/bin/perl -w

use warnings;

use strict;

use Socket;

my ($remote, $port) = split /:/, shift @ARGV, 2;

if (! $remote) {

$remote = 'localhost';

}

print "remote = $remote\n";

if (! $port) {

$port = 8009;

}

print "port = $port\n";

my ($iaddr, $paddr, $proto);

# If the port has anything other than numbers, we're assuming it is an

# /etc/services name.

if ($port =~ /\D/) {

$port = getservbyname $port, 'tcp' ;

}

die "Bad port, stopped" unless $port;

print "port = $port\n";

$iaddr = inet_aton($remote) || die "No host: $remote, stopped";

print "iaddr = $iaddr\n";

$paddr = sockaddr_in($port, $iaddr) || die "sockaddr: $!, stopped";

print "paddr = $paddr\n";

# Grab the number for TCP out of /etc/protocols.

$proto = getprotobyname 'tcp' ;

print "proto = $proto\n";

my $sock;

# PF_INET and SOCK_STREAM are constants imported by the Socket module. They

# are the same as what is defined in sys/socket.h.

socket $sock, PF_INET, SOCK_STREAM, $proto || die "socket: $!, stopped";

print "sock = $sock\n";

print "BEFORE CONNECT\n";

connect $sock, $paddr || die "connect: $!, stopped";

print "AFTER CONNECT\n";

# This is the ping packet. For detailed documentation, see

# http://tomcat.apache.org/connectors-doc/ajp/ajpv13a.html

# I stole the exact byte sequence from

# http://sourceforge.net/project/shownotes.php?group_id=128058&release_id=438456

# instead of fully understanding the packet structure.

my $ping = pack 'C5' # Format template.

, 0x12, 0x34 # Magic number for server->container packets.

, 0x00, 0x01 # 2 byte int length of payload.

, 0x0A # Type of packet. 10 = CPing.

;

my @ping_values = unpack 'C5', $ping;

print "ping_values = " , join ' ', @ping_values , "\n";

# This is the expected pong packet. That is, this is what Tomcat sends back

# to indicate that it is operating OK.

my $expected = pack 'C5' # Format template.

, 0x41, 0x42 # Magic number for container->server packets.

, 0x00, 0x01 # 2 byte int length of payload.

, 0x09 # Type of packet. 9 = CPong reply.

;

syswrite $sock, $ping || die "syswrite: $!, stopped";

my $pong;

$pong = 'empty';

print "BEFORE READ\n";

sysread $sock, $pong, 5 || die "read: $!, stopped";

print "AFTER READ\n";

my @pong_values = unpack 'C5', $pong;

print "pong_values = " , join ' ', @pong_values , "\n";

close $sock || die "close: $!, stopped";

exit 0;

Tomcat and the web.xml's webapprootkey

2010-08-18T09:55:00.002+02:00

I n my company, I have to deal with many Spring based applications deployed on a Tomcat cluster. For each one, we set a property 'webapprootkey' in the web.xml file to avoid errors on startup. Today, I decided to dig about that (... erratum... I decided to tell Google to dig about that). Thus, I found this excellent post.

http://groups.google.com/group/riotfamily/browse_thread/thread/9a0edf69575d3ab6?pli=1

Hi all,

when deploying two applications build from the riot skeleton within the same Tomcat servlet container, you get an IllegalStateException: Web app root system property already set to different value: 'webapp.root' = [/Users/joe/Workspace/.metadata/.plugins/org.eclipse.wst.server.core/tmp0/webapps/webapp-A/] instead of [/Users/joe/Workspace/.metadata/.plugins/org.eclipse.wst.server.core/tmp0/webapps/webapp-B/] - Choose unique values for the 'webAppRootKey' context-param in your web.xml files!

I will try to explain where this comes from and how to circumvent it, but first the quick fix for the impatient reader: Place a context parameter named 'webAppRootKey' in every project's web.xml and assign a value to it, that is unique for every of your projects like the project name itself.

The webAppRootKey context parameter is introduced by Spring. Along with the WebAppRootListener it allows exposing the web applications root directory as a system property. The value of the context parameter 'webAppRootKey' names the system property to use. If the context parameter 'webAppRootKey' is not set in the application's web.xml, Spring chooses the default value 'app.root'. While some servlet containers like Resin do isolate each web application's system properties, others like Tomcat do not. And that's what the former mentioned IllegalStateException is telling us: The system property 'app.root' already contains the root directory of the first web application when Spring tries to assign the root directoty of the second application to it.

Ok, that's the background information. A deeper look into the web.xml tells us, that there ist no WebAppRootListener configured. Why does this initialisation take place anyway? The stack trace from the exception reveals the culprit: The Log4jConfigListener also tries to set the webAppRootKey, because this is an interesting mechanism for the Spring/Log4j integration. It allows log and config file locations relative to the web applications root directory. The Log4jConfigListener supports three init parameters at the servlet context level: 'log4jConifgLocation', 'log4jRefreshInterval' and 'log4jExposeWebAppRoot'. See JavaDocs for more informations.

But, none of these parameters are set in the riot project skeleton's web.xml and none of the Log4jWebConfigureres features are used by the riot project skeleton. As long as you do stay with default log4j setup, the Log4jConfigListener is superflous.

At the end there are three possible solutions for the initial problem:

(1) Provide any of your applications with a unique 'webAppRootKey'.
(2) Set the servlet context parameter 'log4jExposeWebAppRoot' to 'false'. This eliminates the use of log file locations relative to the web application's root directory but still allows a log4j config location outside the classpath.
(3) Remove the 'Log4jConfigListener' from your application's web.xml.

What do you think is the best solution and should be incorporated into the riot skeleton project?

-alf

Alf Werder

Technische Leitung
Head of Engineering

http://www.glonz.com

rpmdb: Lock table is out of available locker entries

2010-07-22T15:38:00.002+02:00

This is what to do to fix this kind of problem :

tar cvzf rpmdb-backup.tar.gz /var/lib/rpm

rm /var/lib/rpm/__db.00*

rpm --rebuilddb

rpm -qa | sort

The first line is to backup your database

The second to remove locks

The third to rebuild your database

The fourth to check if all is ok

Marco read the matrix for Oracle I/O

2010-05-20T10:36:00.001+02:00

Marco sent to me this excellent (EXCELLENT!!) link. As always, this is not a presentation for rabbits!

http://www.pythian.com/news/392/pythian-goodies-oracle-disk-io-basics/

Detect intrusion attacks on Linux

2010-03-12T18:00:00.000+01:00

grep "Invalid" /var/log/auth.log | grep -i ssh | awk '{a[$1$2]++}END{for (i in a){print i " " a[i]}}'

Thanks Marco!

How to fix mouse click problem on flash player 64 bits with Ubuntu 9.10

2010-02-23T21:08:00.003+01:00

I just write here some informations I found on the web. On my Linux Ubuntu 9.10 64 bits, the flash plugin sometimes doesn't register mouse clicks. To fix it, edit the following file by doing :

sudo gedit /usr/lib/nspluginwrapper/noarch/npviewer

and add this export

export GDK_NATIVE_WINDOWS=1

like this

#!/bin/sh

# nsplugin viewer wrapper script...

OS="`uname -s`"

ARCH="`uname -m`"

NPW_LIBDIR="/usr/lib/nspluginwrapper"

export GDK_NATIVE_WINDOWS=1

if test -z "$TARGET_OS"; then

...

Enjoy!

An awesome Lego robot

2010-02-19T11:33:00.002+01:00

Be careful, this is an awesome video! You can also observe that the programmer is using an Acer netbook.

A possible future for our personal computers

2010-02-09T14:43:00.002+01:00

PHP Tips : converting legacy content into UTF-8

2010-01-04T17:36:00.002+01:00

Today, we have encoding problems with legacy apps written in PHP. After some discussions and some googlings, I found this interesting post :

http://www.sitepoint.com/blogs/2008/09/10/issues-with-cultural-integration/

You can read in it :

Latin1 on the inside, utf-8 on the outside
Embed utf-8 within latin1

I copied-pasted just a few lines of code :

// declare that the output will be in utf-8

header("Content-Type: text/html; charset=utf-8");

// open an output buffer, capturing all output

ob_start('output_handler');

// when the script ends, the buffer is piped through this functions, encoding it from latin1 to utf-8

function output_handler($buffer) {

return utf8_encode($buffer);

}

Excellent!

30 Eclipse plugins

2009-12-10T23:14:00.002+01:00

As I was surfing on eclipse.org, I found this link which contains a selection a plugins. I've already tried someone which are very interesting. So, do like me : enhance your Eclipse!

http://www.ajaxline.com/best-eclipse-plugins

A script I found to install Flash on Ubuntu 9.10 64bits

2009-10-24T23:18:00.001+02:00

#!/bin/bash

# Script created by

# Romeo-Adrian Cioaba romeo.cioaba@spotonearth.com

# Super minor updates by jason.melton[at]gmail[dot]com

# Updates by Alejandro Cuervo 3[at]cuervo[dot]net

# more very minor updates by damien[at]groovey[dot]com

# Released under GPL

echo "Closing Firefox"

sudo killall -9 firefox

echo "Downloading and instaling Getlibs for required libraries"

wget http://www.boundlesssupremacy.com/Cappy/getlibs/getlibs-all.deb

sudo dpkg -i getlibs-all.deb

echo "Removing previous installs of flash:"

sudo apt-get remove -y --purge flashplugin-nonfree gnash gnash-common mozilla-plugin-gnash swfdec-mozilla libflashsupport nspluginwrapper

sudo rm -f /usr/lib/mozilla/plugins/*flash*

sudo rm -f ~/.mozilla/plugins/*flash*

sudo rm -f /usr/lib/firefox/plugins/*flash*

sudo rm -f /usr/lib/firefox-addons/plugins/*flash*

sudo rm -rfd /usr/lib/nspluginwrapper

echo "Installing ia32-libs and nspluginwrapper"

sudo apt-get install ia32-libs nspluginwrapper

echo "Getting libs"

sudo getlibs -p libcurl3

sudo getlibs -p libnss3-1d

sudo getlibs -p libnspr4-0d

echo "Installing Flash Player 10"

cd ~

wget http://fpdownload.macromedia.com/get/flashplayer/current/install_flash_player_10_linux.tar.gz

tar zxvf install_flash_player_10_linux.tar.gz

sudo mv libflashplayer.so /usr/lib/mozilla/plugins/

sudo nspluginwrapper -i /usr/lib/mozilla/plugins/libflashplayer.so

echo "Linking the libraries so that firefox can see them."

sudo ln -sf /usr/lib/nspluginwrapper/plugins/npwrapper.libflashplayer.so /usr/lib/mozilla/plugins/

sudo ln -sf /usr/lib/nspluginwrapper/plugins/npwrapper.libflashplayer.so /usr/lib/firefox-addons/plugins/

echo "Done :-)"

echo "You may re-start Firefox now"

Functional Programming For The Rest of Us

2009-10-20T17:39:00.003+02:00

Today, Marco gave me a link to a post made to understand what is functional programming (you know that Microsoft F# is arriving?) :

http://www.defmacro.org/ramblings/fp.html

Thanks Marco!

Domain Driven Design Quickly in french

2009-10-19T13:08:00.002+02:00

Good news for french readers! Guillaume Lebur translated this excellent book.

http://blog.infosaurus.fr/public/docs/DDDViteFaitPartie1.pdf

I realized I was a "ScrumButt" Master

2009-10-02T21:45:00.039+02:00

I've just finished the two days long training session to be a Scrum Master. These two days were lead by Jeff Sutherland (in collaboration with Xebia France) . Of course, don't imagine that you will be great a Scrum Master at the end of the session. As Jeff said, were you a good driver just after obtaining youri driving license?

In this post, I will try to summarize notes I took during the course. It's not exhaustive but it wil give you a global idea of what is Scrum and what should do a Scrum Master.

But, before starting, let's return to the title of this post : "I realized I was a ScrumButt Master". Humm... what's that? Jeff said something very interesting . He asked people about who had already tried Scrum. Many ones in the assistance raised their hand. So, why were they here? ... Ok, let's do another test : can you give me the average velocity of your team? Only two answers iin allt the room. And that's why I was here. As many people, I tried Scrum but not entirely. This is commonly called "ScrumButt" (don't ask me about the two "t", I don't know). And that's why I failed my first Scrum project. Without using all concepts, it smells Scrum, it has got the color of Scrum but it's not Scrum. You see?

Sorry for non-french people, I will continue this article in my mother tongue (which is definitely not Java!).

Après nous avoir demandé de présenter notre voisin, Jeff a fait un rapide sondage histoire de savoir qui travaillait déjà en Scrum (ou, en tout cas, qui avait l'impression d'en faire comme je l'ai dit plus haut...). Il a ensuite reventilé les tables pour avoir des groupes homogènes. C'est un des principes de Scrum : l'équipe ne doit pas comporter de personne qui se démarque. Jeff entend gagner en productivité avec une équipe moyenne.

Scrum, c'est quoi?

Première étape de la formation : présentation du « framework » Scrum. Signalons le tout de suite : pour Jeff, Scrum n'est pas une méthode mais plutôt un cadre de travail pour gagner en performance. Bizarre tout de même, j'ai beau faire le tour de la question, ça ressemble pas mal à de la méthode tout ça. Enfin, on ne va pas chipoter sur les mots. Bref, voici un condensé de ce fameux « framework » :

Les acteurs :

Le Product Owner. En bon français, c'est le chef produit. Enfin... c'est celui qui veut faire faire quelque chose et qui sait ce que ce quelque chose doit faire.
Le Scrum Master. Il anime l'équipe. Il est là pour s'assurer que tous les membres travaillent vers le même objectif. Ce n'est donc pas un « chef » d'équipe dans le sens hiérarchique mais un animateur. Cela peut vous choquer mais c'est dingue le nombre de CdP que j'ai croisés dans ma vie professionnelle qui se prenaient pour des petits chefs... Pourtant, même armé de son diagramme de Gantt, le chef de projet n'est-il pas avant tout au service de son équipe? Et Scrum est assez clair sur le sujet car l'équipe est autogérée.
Le reste de l'équipe projet. Je dit bien « le reste » parce que le Scrum Master en fait partie. Typiquement dans le cadre d'un projet de développement, il développe 50% de son temps. Il est donc pleinement impliqué et ne se contente pas de poser des jalons et de vérifier qu'ils sont respectés! D'autre part, l'équipe (Scrum Master inclut donc) a un rendement optimal si elle est composée de 5 à 7 membres. Au delà, cette productivité s'effondre. Et le mythe du mois-homme dans tout ça? Où il est le bébé fait en un mois par neuf femmes???
Accessoirement, Jeff a insisté sur la nécessité d'avoir un recours à un DBA dans les projets de développement. Il a aussi rappelé qu'un bon architecte est un architecte qui code! Et oui, il doit montrer à l'équipe que ce qu'il a conçu tient la route.

Comment est découpé le projet dans le temps :

Le Sprint. Tout Scrum tourne autour de ça. Un sprint est une unité de découpage temporel du projet avant lequel tout le monde se met d'accord sur ce qui va être fait, pendant lequel l'équi et à la fin duquel l'équipe remet au Product Owner un livrable. Un projet Scrum est composé d'une succession de Sprints. Là, vous devez commencer à sentir la différence avec du projet ordinaire ; Scrum impose de livrer tout au long du projet et non pas à la fin. Dans la pratique, on fait souvent des Sprints de deux semaines. Mais tout est possible. Pendant la formation, Jeff nous a fait faire des Sprints de 3 minutes!
Le Planning Meeting. Cette réunion se fait avec toute l'équipe projet + le Product Owner. L'objectif est de savoir ce que l'équipe va devoir réaliser pour le Sprint à venir.
La Démo : A chaque fin de Sprint, l'équipe doit montrer au Product Owner ce qu'elle a réalisé. Seules les tâches totalement terminées font partie de la démo. La notion de « terminé » est vraiment importante. Par principe, on ne retravaille pas sur ce qui a été livré dans un Sprint précédent donc, autant bien soigner son code dès le début. Rework is Baaaaad. M...kay....
La Retrospective. Petit test : cela fait combien de temps que vous n'avez pas fait de débriefing après un projet? Humm... vous aussi... Et bien en Scrum, on le fait tout le temps! Bref, après la démo, l'équipe fait un point sur ce qui s'est bien ou mal passé histoire de pouvoir s'améliorer au prochain Sprint.
Le Daily Meeting ou « Stand-up meeting » ou « appelez le comme vous voulez du moment que cela ne dépasse pas 15 minutes ». Ce point équipe quotidien permet à chaque membre de décrire ce qu'il a fait la veille et ce qu'il compte faire aujourd'hui. Généralement, ces micros réunions se font debout (ça évite que les participants « s'installent » dans la réunion).

Les outils du Scrummer :

Un paquet de Post-It (on ne rigole pas) pour rédiger les « User Stories ». Les User Stories sont les fonctionnalités attendues. Habituellement, chaque « User Story » est donc notée sur un Post-It collé au mur. Jeff a insisté : pas d'Excel! Chaque fiche comprend :
- L'objectif recherché (le « ça doit faire quoi »)
- Le « How to demo ». Comment tester que cela fonctionne. OBLIGATOIRE! Une fonctionnalité non testable est une fonctionnalité non livrable!
- Un chiffre pour indiquer sa priorité par rapport aux autres fonctionnalités. C'est la « Business Value ». Pensez toujours à ce qui va rapporter le plus de valeur à votre business!
- Un nombre de points indiquant sa charge de réalisation (Courez tout de suite lire la section sur le planning poker pour découvrir illico comment on la calcule, vous ne serez pas déçu). Ces points s'appellent des Sprint Points. Au fait, vous avez vu? On ne compte pas en temps comme d'habitude mais de Sprint Points. On verra plus tard comment estimer en temps la valeur d'un Sprint Point.
Afin de toujours s'assurer qu'une User Story est pertinente, Jeff nous a donné l'acronyme INVEST. Ainsi, une User Story doit être :
- Independant
- Negotiate
- Valuable
- Estimable
- Small
- Testable
Un bout de mur pour coller les Post-Its. L'espace de collage est découpé en zones bien distinctes pour y accueillir :
- Le Product Backlog : il comprend l'ensemble des User Stories du projet. Il est créé par le Product Owner qui les priorise en fonction de leur « Business Value ». L'idée sera bien sûr de réaliser en premier les fiches apportant le plus de valeur métier tout en tenant compte bien sûr de leur complexité de réalisation.
- Le Sprint Backlog. En bon français, c'est quoi qu'est ce qu'on va livrer à la fin du Sprint :) Lors de la réunion de planificaction du Sprint, on pioche dans les Post-Its du Product Backlog.
Un tableau ou un paperboard pour y tracer le BurnDown Chart. C'est un outil très puissant et très simple à réaliser. Il permet de suivre le « reste à faire » du projet et de voir si l'équipe se porte bien. Prenez votre Product Backlog et faites le total des Sprint Points des User Stories. Reportez le sur votre graphique en ordonnées. En abscisse, mettez les Sprints. A chaque fin de Sprint, recalculez de nombre de points restants à faire et reportez le sur le graphique. Et ainsi de suite... Vous avez votre BurnDown Chart. Comment l''interprêter? Si votre courbe est linéaire, c'est que l'équipe travaille de façon homogène. Vous pouvez en plus avoir une idée précise de la date de fin de projet. Si la courbe fléchit, oh la la alerte rouge... il passer en Emergency Sprint Procedure

Les indicateurs du projet :

La vélocité de l'équipe. C'est sa capacité à produire. En outre, c'est le nombre de Spring Points qu'elle est capable de réaliser en un Sprint. Donc, plus vous connaissez votre équipe, plus vous savez combien de points elle peut réaliser en comparaison avec les Sprints précédents. On appelle ça le « yesterday's weather ». Par conséquent, évitez de faire rentrer/sortir des ressources en cours de projet; ça casse toute l'estimation de vélocité. Je vous ai préparé une petite section sur « Comment calculer la vélocité de son équipe » plus loin.
Le BurnDown Chart. Je ne reviens pas dessus. Ce graph synthétise pas mal de choses : le reste à faire, le durée du projet, l'état de santé de l'équipe, etc...
Le « Rework ». Sur l'un des BurnDown Charts que Jeff nous a présenté, il a fait apparaître le coût du code non conforme qui doit être repris. Cela permet de conserver un oeil sur la qualité des Sprints précédents. En principe, le « rework » doit rester faible car l'une des règles d'or de Scrum est de ne pas négocier sur la qualité. Négligence de la qualité = rework. Rework = surcoût.
Le stress de l'équipe. Et oui, il faut y penser. Jeff nous a conseillé de ne pas charger à plus de 70% de leur capacité les membres de l'équipe et à veiller à ce qu'ils ne fassent pas trop d'heures. En effet, stress ou fatique = rework. Rework = surcoût, etc..., etc...

Enfin, j'en ai fini pour la présentation générale du « framework » Scrum. Place au jeu à préssent.

Le planning Poker

C'est l'un des temps forts pour moi de cette formation. L'objectif est d'estimer la réalisation de chaque User Story. Seule l'équipe joue; pas le Product Owner. Première étape, distribution des cartes. Chaque joueur a en main une série de carte dont les chiffres sont une adaptation libre de la suite de Fibonacci. On place une User Story au milieu de la table. Chacun met une carte indiquant son estimation de charge. On retourne toutes les cartes et on compare les résultats. Si il y a moins de 3 points d'écart entre les cartes, la charge de la User Story sera la moyenne de toutes les cartes. Si il y a plus de 3 points d'écart, c'est que l'objectif de la User Story n'est pas compris par toute l'équipe. Dans ce cas, on en discute puis on revote. Et ainsi de suite.... Cela peut paraître étrange mais c'est terriblement efficace.

A la fin de notre exercice, toute la table était d'accord sur le chiffrage et sur ce qu'elle allait faire. Le planning Poker est un bel exemple de travail d'équipe. J'ai beaucoup apprécié.

Calculer la valeur d'un Sprint Point en jours,

heures, minutes, secondes...

Ah, c'est bien beau de faire du poker et de distribuer des Sprint Points mais il y a bien un moment où il va falloir convertir tout ça en temps; notamment pour savoir combien de Sprint Points vous allez pouvoir espérer réaliser pendant un Sprint. Voilà ce que nous a appris Jeff sur le sujet :

Prenez votre plus petite User Story (celle qui est estimée à 1) et découpez la en tâches toutes petites. Toute l'équipe estime alors en temps la charge pour réaliser toutes ces « pitites » tâches. Faites la somme de tout ça et Bingo! Vous avez la valeur d'un Sprint Point.

Je ne vous cache pas que je suis un peu sceptique sur la méthode de calcul. Prendre le plus petit pour l'extrapoler au plus grand... Bon, de toute façon, comme je ne sais pas comment faire autrement, je vais m'en tenir à cela pour le moment.

Calculer la vélocité de l'équipe

Pour rappel, la vélocité de l'équipe est le nombre de Sprint Points qu'elle peut réaliser dans un Sprint. Ca peut paraître bête à rappeler mais la vélocité peut changer d'un Sprint à l'autre. Pourquoi? Tout simplement en fonction des congés ou indisponibilité des uns et des autres.

Bon, commençons simplement. Dès lors qu'on connait la durée d'un Sprint, la taille de l'équipe et la valeur en temps d'un Sprint Point, le calcul le plus simple est le suivant :

Vélocité brute de fonderie = nombre de jours-homme sur le Sprint / valeur en temps d'un Sprint Point

Jusque là, tout va bien. Maintenant, Jeff nous a précisé que le Scrum Master ne doit pas être considéré comme développant à plus de 50%. Donc, pour une équipe de 5 personnes, seuls 4,5 sont prix en compte.

Nombre de JH corrigé = durée du Sprint x (nombre de personnes dans l'équipe - 0.5)

Ensuite, il a rajouté deux choses : soit le ScrumMaster connait l'équipe est dans ce cas, il en connait déjà sa vélocité (le « yesterday's weather » comme on dit dans l'métier...), soit l'équipe est nouvelle et, dans ce cas, on applique des ratios de facto.

Cas 1 : l'équipe est nouvelle

Jeff nous propose d'appliquer deux ratios simples. Pour le premier Sprint, on plafonne la vélocité à 60% de sa valeur théorique. Pour le second, on passe à 70% et dès le troisième, on est à 100%.

Vélocité théorique = nombre de JH corrigé / valeur en temps d'un Sprint Point

Vélocité Sprint 1 = velocité théorique - 40%

Vélocité Sprint 2 = vélocité théorique - 30%

Vélocité dès le Sprint 3 = vélocité théorique

Exemple : une équipe de 5 personnes sur des sprints de 2 semaines. La valeur d'1 point est de 1,5 jours. Je pense ne charger le ScrumMaster qu'à 50%.

Vélocité théorique = 4,5 x 5 x 2 / 1,5 = 30

Vélocité Sprint 1 = 30 - 40% = 18

Vélocité Sprint 2 = 30 - 30% = 21

Vélocité dès le Sprint 3 = vélocité théorique = 30

Cas 2 : l'équipe a de la bouteille (yesterday's weather)

Dans le cas d'une équipe dont la vélocité est connue, il suffit d'appliquer une règle de 3 pour calculer la vélocité du Sprint à venir en fonction du nombre de jours-homme travaillés. Et voilà que j'introduit un nouveau terme : le Focus Factor.

Focus Factor = vélocité précédente / nombre de JH réalisés

Vélocité prochain Sprint = nombre de JH prochain Sprint x Focus Factor

Exemple : Reprenons l'équipe de 5 personnes précédente. Le nombre de points réalisés dans le Sprint précédent où les semaines étaient complètes est de 30. Imaginons maintenant que, dans le Sprint à venir, il y a un jour férié. Le nombre de jours-homme à venir sera de 4,5 x 5 + 4,5 x 4 = 40,5. Si pour 45 jours-homme, la vélocité était de 30, alors pour 40,5, elle sera de 40,5 x 30 / 45 = 27.

Enfin, tout ça n'est jamais qu'une règle de 3.... Scrum reste avant tout du bon sens avec un peu de bling-bling dessus.

Que faire quand le projet dérape ?

C'est une question qui est revenue souvent pendant les deux jours de formation. A cette question, Jeff propose de faire les choses suivantes (dans l'ordre) :

Trouver ce qui ne va pas. Pour cela, Jeff nous a fait travailler sur le « Toyota A3 Process ». Dans la pratique, l'exercice qu'il nous a demandé consiste à mettre à plat un problème sur une feuille A3 organisée en zones bien distinctes. Chaque zone permet d'aller peu plus loin dans la résolution du problème. Une autre technique est celle du « 5 whys ». En gros, une personne expose ce qui ne va pas et on lui demande « pourquoi » jusqu'à temps qu'elle remonte à la source du problème. Quoi qu'il en soit, je crois que Jeff a bien été clair : en Scrum , pour être efficace, il faut éliminer tous les obstacles (quitte à aller au conflit!). « Remove impediments, remove impediments, remove impediments! »
Trouver quelqu'un pour tester.
Retirer la User Story du Sprint
Si aucune solution ci dessus n'est satisfaisante, annuler le Sprint!

Parmi les questions posées par Jeff, il y a eu la suivante : que faire si le Product Owner ne vient jamais au réunions? Réponse : trouver un autre Product Owner. Sachez aussi qu'il peut se faire représenter par un tiers (appelé « proxy »).

Autre question concernant le Product Owner : que faire si plusieurs Product Owners travaillent sur le projet? (C'est en effet parfois nécessaire lorqu'un Product Owner seul n'est pas suffisant pour fournir assez de matière à l'équipe de développement). Dans ce cas, il faut impérativement un Chief Product Owner neutre pour éviter les conflits d'intérêt.

Que faire si l'équipe fait plus de 10% de support? Avouez que ça vous en bouche un coin ça. Contrairement au Waterfall, Scrum intègre directement les élements perturbateurs de la vraie vie tels que le support. Et Jeff a été assez clair sur le sujet. Il dit : dans la pratique, il faut considérer que l'équipe ne travaille réellement qu'à 50% sur le projet. Dans ces 50%, il y a 30% de « new », 10% de « old » (maintenance) et 10% de support. Si les 10% de maintenance ou de support sont dépassés, le Sprint doit être annulé, les problèmes consignés dans une liste des points bloquants (« impediments list ») et le Sprint doit être replanifié.

Que faire si, dans l'équipe, un membre travaille énormément, refuse de venir aux réunions sous prétexte qu'il fait déjà les ¾ du projet à lui tout seul? Réponse : le sortir de l'équipe. Scrum s'appuie sur la notion d'équipe. Si quelqu'un ne joue pas le jeu, il pénalise l'équipe et réduit sa vélocité. Même s'il est très bon!

Aidez votre Product Owner, il vous le rendra!

Le Product Owner est indispensable; alors, autant en prendre soin.

L'équipe de développement peut l'aider à préparer le Sprint suivant à hauteur de 10% de son temps. Pour que les Sprint s'enchainent, il faut bien de toute façon que le Product Backlog soit à jour. Ainsi, à la moitié du Sprint, commencez à aider votre Product Owner à préparer le Product Backlog pour le Sprint suivant.

Pour sa part, le Product Owner doit vous assister en particulier sur la première moitié du Sprint pour comprendre dans le détail les User Stories.

N'oubliez pas qu'une User Story « gros grain » peut être découpée en plus petites User Stories du moment qu'elle n'est pas dans le Sprint Backlog en cours. Cela peut notamment permettre de boucher les trous lorsqu'il reste de la place dans le Sprint Backlog en réunion de planification.

Pour rappel : le Product Owner n'a pas le droit de modifier les User Stories du Sprint Backlog! Paroles de Jeff. En revanche, il peut changer une User Story non réalisée du Product Backlog par une autre de poids équivalent (nombre de Spring Points). C'est le concept « change for free » de Scrum.

Mise en pratique : le XP Game

Ces deux jours de formation se sont terminés par un XP Game; histoire de mettre en pratique un peu de ce qu'on avait vu jusque là. Le jeu était assez amusant. Pour commencer, il a fallu estimer tout un tas de tâches à réaliser (gonfler des ballons, faire des chapeaux en papier, des châteaux de cartes, etc...). Ensuite, nous avons fait nos réunions de planification pour déterminer ce qu'on allait mettre dans chaque Sprint à venir de façon à obtenir une « Business Value » maximale. en un temps restreint Puis, place au Sprint, suivi des demos et retrospective. Le tout avec un zeste de concurrence car Jeff comptabilise les Business Points obtenus pour chaque équipe. Autant dire qu'on s'est bien lâchés. A la fin, il y avait des ballons partout au sol et surtout la preuve par l'exemple que toute la théorie Scrum fonctionne. Et oui, on a tenu la vélocité calculée et nos estimations étaient juste. Par dessus tout, j'ai vraiment eu le sentiment de travailler en équipe dans un objectif commun. C'est probablement un point fort de Scrum : ramener l'esprit d'équipe en entreprise.

Pour conclure

Une très bonne formation même si j'ai senti qu'elle avait du mal à décoller la première demie journée. Au final, je crois que tout le monde aurait bien voulu repartir avec Jeff dans sa valise. Pour preuve, les deux jours se sont terminés par une séance photo avec la star de Scrum. Alors que conclure si ce n'est vous conseiller de suivre cette formation...

Thanks a lot Jeff.

Pour aller plus loin :

http://www.infoq.com/resource/news/2007/06/scrum-xp-book/en/resources/ScrumAndXpFromTheTrenches_French.pdf

Use exotic Maven repositories with your local mirror

2009-09-24T16:34:00.005+02:00

This is a little tip you must know if you have an "in-house" maven repository mirros (such as Artifactory) and if you want to access to an exotic one.

What's an exotic repository? My definition of that is a repository hosted by a developer isolated somewhere on the web. Of course, it's not a mirror of the official one. By the way, you should not declare it on you "in-house" mirror but simply write the following lines in your pom.xml :

<repositories>
<repository>
<id>violet.repo</id>
<name>Violet's Maven repository (public access)</name>
<url>http://violet.sourceforge.net/maven2/repo/</url>
</repository>
</repositories>

Now, imagine you try to retrieve an artefact. Muupp... error! You miss to declare an exclusion in your settings.xml to inform Maven that it should not use your local mirror to get it. Thus, this is an example of what to do :

<mirrors>
<mirror>
<id>artifactory</id>
<mirrorof>*,!violet,!wicketstuff,!google</mirrorof>
<url>http://localserver:8080/artifactory/repo</url>
<name>Artifactory</name>
</mirror>
</mirrors>

You understood the "!" character? M...kay... That's all for today.

Want to trace network activity of your Microsoft Windows platform?

2009-09-24T15:03:00.002+02:00

A good starting point is Fiddler :

http://www.fiddler2.com

Of course, it's free.

Speed Up your FireFox on Linux

2009-09-20T22:17:00.002+02:00

You can't imagine how Firefox loves to write temporary files. I realized it on my Acer Aspire One with its ugly 8GB SSD. An excellent tip I read on the web consists in mounting a directory in memory and configuring FF to use it.

Let's go :

sudo gedit /etc/fstab

Add the following line :

tmpfs /tmp tmpfs defaults,noatime,mode=1777 0 0

In Firefox, open this internal URL :

about:config

Right click to add a new string entry :

browser.cache.disk.parent_directory

Set its value to

/tmp

Reboot your machine and appreciate...

Of course, this tip is certainly portable on Microsoft Windows with softwares like RamDrive even if I presented it on Linux.

Installing an Apache Tomcat cluster

2009-09-10T16:36:00.002+02:00

I'm currently reviewing some scripts to install a Tomcat cluster. A nice way to do that is to have a common Tomcat installation and the minimum needed for each node. There's a an excellent introduction on the subject by Filip Kanik :

http://www.springsource.com/webinar/large-scale-tomcat-deployments

Then, you will find here an example of the run.sh file introduced by Filip :

http://sirinsevinc.wordpress.com/2009/07/20/deploying-multiple-tomcat-instances/

Where is my Tomcat Adapter for WTP in Eclipse 3.5 (Galileo) ?

2009-07-27T18:03:00.002+02:00

I downloaded Galileo a few days ago. But, when I tried to test my webapp on my favourite Tomcat, I discovered that it missed the corresponding adapter. Wooo... After some searches (thanks to Google), I found the easiest way to install it and (by the way) all the other adapters. From the WTP update site (http://download.eclipse.org/webtools/updates/), select and install JST Server Adapters.

That's all!

Move a project from an SVN repository to another one

2009-06-30T15:10:00.002+02:00

Today, I need to move a project from a first subversion repository to a second one. To do that, you need to have an access to your SVN server.

So, we will use the following commands :

svnadmin dump to backup the repositories (I insist on 'repositories'. I think it's important to have backups of all repos before doing such operations)
svndumpfilter to reduce the backup scope to a single project because the dump can only be done on the entire SVN repository
svnadmin load (I think you can guess what this wonderful command does)

To understand this commands, it's important to know that svnadmin uses standard inputs and outputs. Thus, we can combine commands with pipes.

Let's save our project (with all its history, tags, branches...)

svnadmin dump /home/subversion/svn/repo/ | svndumpfilter include myproject > svn.myproject.dump

Now, let's backup our target repository :

svnadmin dump /home/subversion/svn/new_repo/ > svn.new_repo.dump

And let's import the project on this target repository :

cat svn.myproject.dump | svnadmin load /home/subversion/svn/new_repo/

Important note : when you use svndumpfilter, the keyword you give to the filter is only a prefix. That's very important because if you have similar project names, you must excluse the ones you don't want like that :

cat svn.myproject.dump | svndumpfilter exclude myproject2 > svn.myprojectonly.dump

Wow, that's all!

Modify your host networking interface with Virtual Box OSE 2.0.4

2009-06-17T15:26:00.001+02:00

In the previous post, I talked about how to start a Windows XP image downloaded from Microsoft to be able to test your web application with Internet Explorer.

On Ubuntu 8.04 and Virtual Box OSE (Open Source Edition) 2.0.4, there are some fixes to do before being able to work with the hosted mode network interface.

I took the following instructions from the french Ubuntu forum (http://forum.ubuntu-fr.org/viewtopic.php?id=217680).

1) install bridge-utils and uml-utilities (sudo apt-get)
2) add the vboxusers usergroup to your user :

$ sudo usermod -a -G vboxusers

3) Create a bridge by modifying you /etc/network/interfaces file

For DHCP conf

$ sudo gedit /etc/network/interfaces
auto eth0
iface eth0 inet manual

auto breth0
iface breth0 inet dhcp
bridge_ports eth0

# The loopback network interface
auto lo
iface lo inet loopback

For static IP conf

$ sudo gedit /etc/network/interfaces
auto eth0
iface eth0 inet manual

auto breth0
iface breth0 inet static
bridge_ports eth0
address 192.168.0.2
netmask 255.255.255.0
gateway 192.168.0.1

# The loopback network interface
auto lo
iface lo inet loopback

Note that your dns should be declared in the /etc/resolv.conf file.

4) Add your virual interfaces toAjouter vos interfaces virtuelles dans le fichier : /etc/vbox/interfaces

$ sudo gedit /etc/vbox/interfaces
# Each line should be of the format :
# []
vbox0 breth0
vbox1 breth0
vbox2 breth0

5) Reboot (startup is longer due to this new interfaces)

6) Open your virtual box settings. Go to network pârameters, Select host interface and declare the following parameters :

Interface Name : vbox0
Setup Application : /etc/network/if-pre-up.d/virtualbox-ose
Terminate Application : /etc/network/if-post-down.d/virtualbox-ose

Internet Explorer free under Ubuntu Linux with VirtualBox

2009-06-17T11:02:00.000+02:00

This is a title I found on a blog (http://www.railsgeek.com/). You all know this kind of crisis when delivering a web application developed on your favourite Linux with FireFox : your piece of software crashes on Internet Explorer. You also know how it's difficult to have a IE quickly running on your Ubuntu. Perhaps you tested IE4Linux but it's an old projet. Thanks to Microsoft (yes, I can say this), you have a solution from now.

1) Go to the Microsoft download website : http://www.microsoft.com/downloads
2) Enter 'vpc images' in the search text field
3) You will have an answer titled :

IE App Compat VHD
VPC Hard Disk Images for testing websites with different Internet Explorer versions on Windows XP and Windows Vista

4) Click on the link and download an image (I took IE7-XPSP3.exe)
5) Rename it with the rar extension (ie IE7-XPSP3.rar) and unrar it
6) Install VirtualBox with Synaptic. This excellent software is able to read Microsoft Virtual PC image disk (VHD)
7) The first time you start your Windows, you will probably have a blue screen on processr.sys. So, restart in safe mode with the command prompt.
8) Find and rename processr.sys

cd \WINDOWS\system32\drivers
ren processr.sys processr.old

9) Reboot and install the Virtual Guest Additions

Ultimate note : after guest additions installation, my VBox crashed and refused to restart due to a problem when accessing to the disk image. To fix this, I found the following solution which consists on converting de Virtual PC disk image to a VMWare one using QEMU like this :

qemu-img convert XP\ SP3\ with\ IE7\ 2009-Apr.vhd -O vmdk XPSP3.vmdk

In love with my linux shell

2009-06-11T17:44:00.000+02:00

Just a tiny link to a really interesting website which concentrate common and useful linux command lines :

http://www.commandlinefu.com

Thanks Marco for this URL!

An easy way to export java classpath on linux

2009-06-02T10:46:00.000+02:00

Simple but powerful, you just need to be in your lib folder and type :

export CLASSPATH=$(pwd)/*

That's all!

Zenika Wicket Contest / Concours Wicket Zenika

2009-04-10T02:14:00.000+02:00

It's exceptional but I wrote this post in french. It's about a contest which proposed to developed a tiny Apache Wicket project with another framework. I tried to implement it with SmartGWT.

Bon et bien voilà : je livre mon appli ZenContact migrée en GWT. Je vous préviens, je ne vais pas trop mâcher mes mots. L'objectif du concours est assez clair : refaire une petite appli de gestion de contacts réalisée à l'occasion d'une présentation Wicket au Paris JUG; le tout avec un petit défi en plus car cette présentation menée par Zenika n'a duré qu'une heure.

Bref, devant l'enthousiasme général, j'ai entrepris de la refaire en GWT. Et comme il fallait aller vite, j'ai choisi de m'appuyer sur des outils et API pour avoir le moins à coder possible. Je fixe rapidement la stack de travail : Eclipse 3.4, Maven 2, SmartGWT. Bon, c'est parti! New maven project -> template gwt. Je teste l'application générée par le plugin Maven. Jusque là tout est OK. Un bonheur.

Je n'ai jamais travaillé avec SmartGWT mais ça a l'air assez riche. Je garde toujours firefox en arrière plan avec la démo de l'API. Je copie-colle des bouts de code et en 3 heures j'ai mon formulaire, mon tableau éditable, le drag and drop, le date picker et tout le reste. Pas mal... Je décide d'arrêter là pour le premier jour.

Le code du tableau triable/editable avec drag and drop : impressionnant non?
contactGrid = new ListGrid();
contactGrid.setWidth(300);
contactGrid.setHeight(224);
contactGrid.setAlternateRecordStyles(true);
contactGrid.setShowAllRecords(true);
contactGrid.setCanReorderRecords(true);
contactGrid.setCanDragRecordsOut(true);
contactGrid.setDragDataAction(DragDataAction.COPY);
contactGrid.setDataSource(this.datasource);
contactGrid.setAutoFetchData(true);
contactGrid.setCanEdit(true);
contactGrid.setEditEvent(ListGridEditEvent.DOUBLECLICK);
contactGrid.setEditByCell(true);

Le lendemain, je passe à l'intégration des pages de l'application Wicket d'origine dont je reprends les 3 fichiers html. Premier problème : j'ai trois pages. Ca fait 3 modules GWT. Pour rappel, pour les petites applications GWT, tout se met dans un seul et même module. Tant pis, je conserve les pages; ça sera l'occasion de me lancer dans la communication entre modules, je ne l'ai jamais fait. Pour cela, j'opte pour une solution pipotesque qui consiste par passer par un cookie. En principe, tout doit rouler car j'ai repéré que SmartGWT travaille tout en JavascriptObject transformables en chaines JSON. Vous voyez où je veux en venir... Et c'est là que les ennuis commencent. Impossible de convertir simplement ma datasource. Je commence à chercher dans la documentation SmartGWT... ah, j'oubliais : il n'y en a pas en dehors de la démo! Je regarde donc du côté de l'API. Le moins que l'on puisse dire, c'est que ça ne manque pas de méthodes. C'est riche, très riche, tellement riche que je ne sais pas quoi en faire. Les petits tours dans le code source me refroidissent vite fait car SmartGWT utilise JSNI à outrance dans la mesure où il ne fait que du wrapping de javascript. Après quelques heures, je trouve la solution. Fin de l'épisode du jour.

Je laisse le projet de côté pendant quelques jours avant de m'y remettre pour le packager. Je reteste quand même vite fait avant. Et là : deuxième problème. Mon tableau n'affiche plus de données. Bizarre. Je m'arrache les cheveux à coup de debugger. Tout a l'air correct.... Je n'y comprends rien. Je recherche du côté de la démo de SmartGWT et me rends finalement compte d'une ligne récurrente dans pas mal d'exemples de code. Un « setAutoFetchData(true) ». Je teste mon code avec ça : bingo! Ca marche! Je réalise à présent qu'en plus d'être trop riche, SmartGWT n'est pas dans un état fini. Je m'imagine dans un contexte de production à chercher ce genre de bug... Bon,avec tout ça, je n'ai pas eu le temps de packager. J'arrête les frais pour aujourd'hui.

De retour sur le code, je redécouvre GWT (je n'en fait plus depuis quelques mois). Pour rappel, 1 module compilé = 1 emplacement pour les fichiers générés. Mais avec mes trois pages, ça ne va pas du tout. Par exemple, WelcomePage.html se retrouve dans tous les répertoires et, comme les liens entre les pages restent relatifs à chaque module, je ne peux pas passer d'un module à l'autre. Bref, je recherche comment faire sur le forum GWT et implémente une petite solution assez simple me permettant de ne travailler qu'avec un seul module.

Enfin, c'est fini! L'application n'est pas complètement bouclée mais je n'irai pas plus loin. Il est d'ailleurs temps d'écrire mes conclusions sur le projet.

Tout d'abord, j'ai été impressionné par les progrès d'intégration des développements GWT dans Eclipse. Cela est clairement dû à l'intégration Maven. Et oui, Maven, on peut dire ce qu'on veut dessus mais c'est tout de même l'esperanto de l'IDE.
Ensuite, j'ai été surpris par la rapidité de prise en main de SmartGWT. La démo est bien faite même si le code source montré n'est pas complet et qu'il faut vite télécharger la suite. Ce framework propose des fonctionnalités très poussées. C'est très agréable... au début seulement. Rapidement, on voit bien que l'API est trop riche. Ca part dans tout les sens. Elle n'est pas guidante et c'est dommage car le code produit au final est plutôt satisfaisant. Cela provoque une courbe de développement chaotique. Au premier bug, c'est l'explosion du temps de développement et la chute de cheveux assurée. Et par dessus cela, comme on est sous GWT, le temps de compilation est (très long) et chaque test devient un calvaire.

Alors, quid de la solution GWT par rapport à la version Wicket? Et bien vous l'aurez compris, je déconseille l'utilisation de SmartGWT pour le moment. L'API n'est pas mature. Elle a toutefois l'intérêt d'être très bling-bling pour les démos. Pour ce qui est de GWT, l'intérêt se situe sur son orientation « client centric ». Et oui, l'application dans sa version actuelle tourne sur un simple serveur Apache lorsque Wicket demande un Tomcat. Mais quelle lenteur ce compilateur Javascript/Java! Finalement, cette expérience confirme l'avis que m'était fait sur ces deux frameworks :
GWT est un excellent framework pour les applications à interactivité utilisateur forte. Ses capacités de manipulations des objets DOM et de gestion des évènements du navigateur sont excellentes.
Dans le cas d'une application de gestion classique, Wicket est un choix bien plus judicieux. L'utilisation des « Model », la gestion des conversations, le développement loin de javascript (qui est quand même un vrai langage de merde!), l'intégration Spring, l'internationalisation, le code source clair sont autant de points qui font du développement avec Wicket un vrai bonheur.

Pour finir en quelques mots : Wicket c'est une Renault. Ca marche plutôt bien au quotidien. GWT, c'est une Ferrari. C'est beau une Ferrari. La super éclate le week-end. Mais pour aller chercher le pain, ce n'est pas forcément le mieux.

Télécharger le projet compilé (à dézipper + trouver le WelcomePage.html) : zencontact_gwt.zip

Télécharger le code source : zencontact_gwt_src.zip

Why can I access to port 8080 only from localhost on Ubuntu?

2009-04-08T13:05:00.000+02:00

To achieve the previous post, I had some problems today to access to my tomcat server from another machine. Ping OK but telnet 8080 KO... Humm, this smells firewall rules. Bingo! I didn't considered iptables as a firewall but it's one!

So, if you are in a secure network area, you can disable it temporarily with the following command :

sudo iptables -F

You can go further by reading this how-to page : https://help.ubuntu.com/community/IptablesHowTo

TCP Port 80 blocked on Ubuntu

2009-04-07T17:11:00.000+02:00

While working on project, I had to bind my Tomcat to port 80 (instead of deploying an Apache and configuring its mod_jk). But, as you should know, Unix systems contains default security rules. Ports below 1024 are only allowed to the root user. Humm... it was time to work with iptables!

The following commands would show you how to add a rule to redirect request on port 80 to port 8080 and how to remove this rule.

Adding a rule :

sudo iptables -t nat -I OUTPUT --src 0/0 --dst [YOUR_IP_HERE] -p tcp --dport 80 -j REDIRECT --to-ports 8080

Saving it :

sudo iptables-save

Listing rules :

sudo iptables -t nat --line-numbers -n -L

This will show rules ordered by REDIRECT, PREROUTING, POSTROUTING and
OUTPUT. Each line start wil a number.

Deleting a rule :

sudo iptables -t nat -D [REDIRECT, PREROUTING, POSTROUTING or OUTPUT] number

Ex : sudo iptables -t nat -D OUTPUT 1

Why is agile software development like teenage sex?

2009-02-06T11:14:00.000+01:00

Today, Romain Gauthier (OCTO Technology, for the moment) sent me a funny post on Agile development. I really like Agile methods but it's so funny that I had to paste it here :

Why is agile software development like teenage sex?

It's on everyone's mind all the time.
Everyone is talking about it all the time.
Everyone thinks everyone else is doing it.
Almost no one is really doing it.

The few who are doing it are:

doing it poorly
hopeful it will be better next time
not practicing it safely

Unfortunately, it sticks to reality... Bahhh, Romain, I hate you. You tried to shake me but I will continue to promote SCRUM.

Source : http://dnicolet1.tripod.com/agile/index.blog?entry_id=1877790

How your XML parser can detect encoding?

2009-02-03T09:58:00.000+01:00

I've just fined a tiny article which describe how XML parsers detect document encoding. I hope you already know this but it always good to read it again. In a few words, parsers use the first document characters which are the same in all xml document and try different ways to read them and evaluate encoding.

http://www.xfront.com/specifying-encoding/index.html

Stay hungry, Stay foolish!

2009-02-02T23:31:00.000+01:00

[VOSTFR] Steve Jobs Stanford Commencement Speech, 2005

Thanks Mister Jobs! I think that I will listen to you over and over.

Maven best practices

2009-01-22T10:13:00.000+01:00

Today, my friend Marco sent me a great blog entry on Maven best practices. In a few words, it says :

Automate Snapshot Deployment by integrating your project in a CI system (like Hudson)
Isolate Local Repositories using use -Dmaven.repo.local=xxxx option to define the unique local repositories for each build.
Regularly Purge Local Repositories (mvn dependency:purge-local-repository)
Enable Batch Mode with the -B option to reduce log size
Enable Full Stack Traces (-e) when there's a build error
Print Test Failures to Standard Output (in your settings.xml : true)
Always check for Snapshots (-U option); useful when your project is split in modules and libraries. This ensures you always have the last dependency library release on your project.

Click here to see the full post : http://blogs.sonatype.com/people/2009/01/maven-continuous-integration-best-practices/

Thanks Marco!

Making Eclipse look better on Ubuntu

2009-01-06T11:45:00.000+01:00

I started today to find the simplest way to make my Eclipse look better on Ubuntu. I've got a laptop (so, I'm used to work with an LCD screen). Here is my solution :

Step 1 : install the ttf-liberation package
Step 2 : open your system->preferences->apparence menu. Go to the font tab and change fonts like that :

Application/Document/Desktop font: Liberation Sans, size 9
Window title font: Liberation Sans Bold, size 10
Fixed with font: Liberation Mono, 10

Select the LCD screen optimization features (including in the User Details options).

That's all!

Spelling API

2008-11-26T09:40:00.000+01:00

Today, my friend Marco gave me a great API which can help on auto completion forms. This spelling API is based on a ternary tree and seems to be a good entry point to build a search engine.

Thanks Marco!

http://jaspell.sourceforge.net/

GWT widgets showroom

2008-11-24T11:48:00.000+01:00

I haven't published any post about GWT for a long time. Today, I found a website showing GWT widgets, panels, listeners... in action. It's great when you have to make choice between two kinds of panel; this site allow you to see their behaviors.

http://examples.roughian.com/

Let's talk about design patterns

2008-11-03T14:40:00.000+01:00

Do you know the difference between Adapter and Decorator patterns?

These two patterns are made to wrap objects. Humm... Same goals? Not exactly. On the first hand, the Adapter pattern is used to transform your class interface contract to another one. In the real world, you use it to "adapt" your code to an external piece of code you need.

In the other hand, with the decorator pattern, your class keeps its interface contract. You just wrap your code to bring some new features. For example, you decorate a class to integrate a counter on method calls and perform a performance test.

Oracle quick start guide

2008-10-24T17:48:00.000+02:00

Just a link to an Oracle quick start guide to remember :

http://www.exforsys.com/tutorials/oracle-9i.html

IntelliJ shortcuts vs Eclipse shortcuts

2008-10-24T11:15:00.001+02:00

Recently, I started to work with IntelliJ. But, honestly, after several years with Eclipse, it's hard to be effective because of key shortcuts which are different between the two IDEs. A little request on Google and I found this (great!) :

Description	Eclipse shortcut	IntelliJ Shortcut
Navigate a Java Type	CTRL + ALT + T	CTRL + N
Navigate a Resource	CTRL + ALT + R	CTRL + SHIFT +N
Last Modified Source	ALT + Left arrow	CTRL + ALT + left arrow
Debug	F11	Shift + F9
Open Declaration	F3	CTRL + SHIFT + B
Open Hierarchy	F4	CTRL + H
Organize Imports	CRTL + SHIFT + O	CTRL + ALT + O
Find	CTRL + F	CTRL + F
Find Again/ previous	F3 / SHIFT + F3	F3 / SHIFT + F3
Step Into	F5	F7
Step Over	F6	F8
Step Out	F7	Shift + F8
Resume	F8	F9
To find impl of an abstract Method	?	Ctrl + Alt + B
To find usage	CTRL + SHIFT + G	Alt + F7

Let's SCRUM

2008-10-23T00:43:00.000+02:00

Yes, it's time to start a new project. A classic fact is that user specifications are not yet completely defined. Humm, but I need to start the project. The only solution will be to be agile. So, let's SCRUM. It's the first time for me. I read some docs from the past but I never really tried it. Thus, I spent this evening reading charts, blogs, etc... I also found a good french video preformed by a SCRUM senior (having 4,000 hours flying on agile projects) :

Planification et gestion de projet informatique : SCRUM
par intellicore

Google App Engine will support Java

2008-10-20T23:10:00.000+02:00

Excellent news! There was an empty place on the web : it was barely impossible to find free hosting for java applications. The main reason is certainly due to the runtime heavyweight. For example, a java apps consume a lot of cpu and i/o charges on JVM startup. Another reason is the total cost ownership of java servers. Let me try a little comparison : if a PHP engine is like a old car (not really powerful but strong for many usages and maintenance free), a Java engine is like a Ferrari : really performant but really horrible to manage, to tune, to maintain, etc... Now imagine that you're at the head of a low cost rental company. What should you prefer : offering PHP cheap engine or Ferrari ones? You see what I mean... But, in the other hand, what's a frustration for millions of java developers like me! I was forced to program in PHP for my webapps. (and I'm really not a PHP killer). Hopefully, graceful to Google, you will be able to have online apps using Google App Engine!!! So great, So nice, So... there's no word! Of course, I hope you will use GWT for your frontend...

Database design

2008-08-14T14:44:00.000+02:00

Database design is often made by programmers. This is common mistake . Only a few developers know internal db structure and mechanisms. Let's doing a tiny test :
1) Describe me what's an hash table?
2) Give two link of indexes and when it should be used?
3) What about isolation transaction levels?
OK, OK, I stop here.

Although db design should be done by specialists, it's never to late to improve our knowledges. Thanks to my friend Marco, I put here a link to a website which published db models. From know, before designing your model, don't forget to check if a similar one already exists.

http://www.databaseanswers.org/

GWT : the unofficial Wiki

2008-06-26T22:25:00.000+02:00

Let's continue in our GWT investigations... I've just found the "unofficial" wiki. It here :

http://google.wikia.com/wiki/Google_Web_Toolkit

A french GWT tutorial

2008-04-28T11:46:00.000+02:00

Today, I found a post on a blog written like a tutorial. It covers from the installation to deployment on a server.

http://jl2tho.blogspot.com/2007/09/tutorial-gwt-g0.html

An introduction to GWT

2008-04-21T10:31:00.000+02:00

I found a PPT introducing GWT. Since it is based on Bruce Johnson and Didier Girard presentations, don't hesitate to read it :

DevHive :: The Swarm Development Platform: Presentation: Introduction + Lessons Learned Using Google Web Toolkit (GWT)

The Tomcat French Corner

2008-03-13T17:16:00.000+01:00

Here is a link on french documentation about Tomcat 5.

http://www-igm.univ-mlv.fr/~dr/XPOSE2003/tomcat/tomcat.php

Feeling sad with Eclipse on Linux

2008-02-06T02:03:00.000+01:00

Humm, something is broken : my trust in Eclipse quality.

I recently installed an Ubuntu 7.10 on my laptop. Then I added Eclipse 3.3 with Sun Java 6. After several days (weeks...), it tastes unstable. Not Ubuntu! (Of course)... but Eclipse. Here is a list of problems I encountered :

problem with VCS (when comparing files with a repository for example)
problem with auto-imports (so I have to use "Reorganize imports" instead
problem with Java and Debug perspectives that change views positions by itself
something, Eclipse goes slowly during a few seconds (???)
and... the ugly big fonts they use that make my 17 inches screen looking like a 15 inches one.

So, I hope Eclipse 3.4 will fix that (or I will go back to the Win32 version. Hopefully VMWare exists)

Make beautiful presentations

2007-12-06T15:16:00.000+01:00

It's always the same headache : you have to make a presentation and want it to look professional. Don't worry, pick up a PowerPoint template on Microsoft site :

http://office.microsoft.com/en-us/templates/default.aspx

13949712720901ForOSX (we want Java 6 on MacOS X)

2007-11-05T11:48:00.000+01:00

Last week, Apple publishede a new release of its famous MacOS. But... why?.... don't uderstand... where is Java 6? It seems to be an Apple decision not to include Java on its new platform. By the way, Henry Story invited all blogger to put an entry in their blog to protest against this situation.

So : 13949712720901ForOSX

http://blogs.sun.com/bblfish/entry/vote_for_java6_on_leopard
http://www.javalobby.org/java/forums/t103042.html

Debugging with Samuraï

2007-06-13T18:03:00.001+02:00

Samuraï is a piece of software starting with Java Web Start and reading Core dumps.

So when you're application is frozen, run a kill -3 [pid] to obtain a core dump and drag'n drop it into Samuraï. This will help you to qualify bugs.

http://yusuke.homeip.net/samurai/?english

A mapping framework...

2007-05-30T14:10:00.000+02:00

I've just discovered a new mapping framework with many possibilities for mapping beeans to beans or maps to beans or anything else.

http://dozer.sourceforge.net/

ITIL : new ideas, new directions...

2007-04-16T15:19:00.000+02:00

I spoke with a friend who tells me about ITIL. ITIL agregates best practices in computer sciences (not only technical, but management, financial...). I think I will have a close study on it. So, I added two interesting links (the first one is in french, sorry for english people)

http://www.itsmf.fr/

http://www.itil.co.uk/

Technical video presentations

2007-04-03T14:54:00.000+02:00

My friend Marc Godin sent me a link on a website publishing technical présentation videos. I'm sorry but you will probably have to stop watching Desperate Housewifes!

So, that's it :

http://www.parleys.com

Agile project management

2007-02-02T17:19:00.000+01:00

Here is an article (in french about a project management approach). I just read a few words about it but it seems to be interesting. My opinion is that a project manager has to be a "real" member of his team and not upon it. When I was team leader, I tried to be like that : a "real" member. In fact, this project was good and work was efficient. It was a "real" team.

http://www.valtech-mag.com/mag/fr/1.html

Managing text encoding in Java properties files

2007-01-21T00:39:00.000+01:00

Something interesting when you write a software is to translate it. Java has this feature embedded. You simply have to write properties files and use a resource bundle to extract texts in your program. Consult ResourceBundle class javadoc for more information about how to proceed.

Something else very ineresting in about properties file encoding. Java specification supposes this sort of files to be written in ISO-8859-1. Oops! What about translating my software into japaneese? No problem, you cas use "unicode" codes in your files.

For exemple, to translate é, replace it by \u00E9 in your properties file. You can consult www.encoding.org for more informations aboiut encodings.

Thus, if you want to retreive characters codes, I propose you think excellent web page (in french) :
http://hapax.qc.ca/conversion.fr.html

Speed up Microsoft Windows XP explorer

2007-01-03T15:04:00.000+01:00

Something very boring : Microsoft Windows XP explorer inspects zip files. This could really decrease performaces.

So ...

If you want to turn of WindowsXP showing Zip files as folders,
just run:

regsvr32 /u zipfldr.dll

An excellent article on functional programming

2007-01-02T17:42:00.000+01:00

http://www.defmacro.org/ramblings/fp.html

Thanks Marco!

Calendar OGNL expression for Luntbuild

2007-01-02T11:53:00.000+01:00

Wow, that's my first message with year that I started with Luntbuild. I looked for an ognl expression to preform build only in a specific time range.

So, after reading the documentation and surfing on forums, I found the class OGNLHelper on Luntbuild CVS repository. Bingo!

Here is a exemple of a expression that returns true in a specific time range :
(system.getHour() in {0,1,2,3,4,5,6})

In this example, build will be done betwenn midnight and 6:00am.

How to force decimal separator char upon java region code?

2006-12-04T10:53:00.000+01:00

Java application could be run on any compliant platform. And that's great. But, when you provide it to your customer, you don't know the region code of his server. For exemple, you don't know if is configured to work in english or french.

By the way, let's take the previous example. In franch, decimal separator char is ',' (comma). In english, it is '.' (dot). When prensenting data to end user, you probably want to ensure that the decimal separator char is the right. So, you can for it usiing DecimalFormat.

Let's see it in the following code :

public class AfficheurDecimal {

public AfficheurDecimal() {
testerReste(100);
testerReste(0);
testerReste(12354.12854);
}

private void testerReste(double reste) {
if (reste != 0) {
DecimalFormat formatEntier = new DecimalFormat("0.00");
DecimalFormatSymbols symbols = formatEntier.getDecimalFormatSymbols();
symbols.setDecimalSeparator(',');
formatEntier.setDecimalFormatSymbols(symbols);
String msg = "Il reste " + formatEntier.format(reste) + " à ventiler";
System.out.println(msg);
}
if (reste == 0) {
System.out.println("Pas de reste");
}
}

/**
* Auteur : a.depellegrin

* Définition :

* @param args
*/
public static void main(String[] args) {
new AfficheurDecimal();
}

}

That's all!

Multibase application could be like in the song : it's just an illusion

2006-11-13T11:45:00.000+01:00

Today, my friend and excellent architect Marc Godin told me something very interesting that sumarize an illusion that java introduced with its virtual machine. He said :

"L'adhérence a la base de donnée est à acter comme celle à la JVM"

Sorry, it's in french. BTW, the text tells that you had to choose your database as you chose you JVM.

Testing frameworks

2006-11-06T14:04:00.000+01:00

A good repository :

http://www.opensourcetesting.org

Special caracters in HTML

2006-11-02T15:36:00.000+01:00

Something very usefull :

http://www.commentcamarche.net/html/htmlcarac.php3

Why primitive types are unprecises? the unacceptable explaination...

2006-10-31T15:47:00.000+01:00

Another excellent article by Brian Goetz on numerical java data type storing. It's just a question of IEEE 754. So, don't expect to work with primitive types in Java for finacial applications. Such a pity! My old Casio FX-7000 is more powerfull than my computer.

Financial programs represents a major part of softwares all over the world. If you want my opinion, its unacceptable to have to work with wrapped types!!!

James Goslin, any solution? You're welcome if you have one.

http://www-128.ibm.com/developerworks/java/library/j-jtp0114/

Open ESB

2006-10-27T16:26:00.000+02:00

Great news,

I just learnt that Sun launched an open source ESB project with a tool suite for NetBeans. This fact of having developped graphical tools to design processes and mappings is a very (VERY) important point in my point of view. Something tells me that, if the product is well done, the situation will be harder for webMethods in several months.

I will publish my Violet UML Editor as quickly as possible to investigate on it.

http://www.netbeans.org/kb/55/bpel_gsg_project.html

http://open-esb.dev.java.net/

Oracle error codes

2006-10-18T12:00:00.000+02:00

Just a list with Oracle error codes :

http://www.oracle.com/pls/db92/db92.error_search

Searching files on unix

2006-10-12T18:40:00.000+02:00

Want to find files and perform massives operations on them, here are tws sample commands for unix platforms :

find -name "[filename]"

find -name "[filename]" -exec [command] '{}' \;

where [filename] and [command] should be replaced by real values. [command] is another unix command to execute on each file found. The file found is represented by '{}' in the command to execute. \; indicates to end of the command.

Ex : find -name "*.tmp" -exec rm '{}' \; -> deletes all tmp files.

CVS activity : extract history for a user and from a date

2006-10-05T17:26:00.000+02:00

cvs -d :pserver:[user]@[server]:/[repository] log -d ">2006-09-28" -w[user]

where
[user] is the username
[server] your server location
[repository] the CVS repositpry url

Of course, don't forget to change the date!

Hibernate 3 and Oracle 9i cursors : how does it work?

2006-10-02T15:25:00.000+02:00

Here is a post I found on the hibernate forum. It explains why cursors opened are not released on session.close() :

OK. Here's the result of this thread:

For the environment, JDK1.4.2_01, Oracle 9i server, oracle 9i jdbc driver (ojdbc14.jar) and oci connection to the database (not thin driver);

There's no problem with hibernate's prep stmt cache nor with Oracle Jdbc driver with regard to cursors remaining open after Session.close().

Every Session.iterate() and Session.load() calls cause a prep stmt to be created on the server side. And after you close the session with Session.close(), hibernate explicitly calls appropriate driver methods to close the resultsets and prepared statements.

However, after you close the session, you won't see the cursors de-allocated (or closed) on the server side. While it seems to be a bug, it actually is not. The driver maintains a list of prep statements and open cursors in its memory and as soon as you re-use the same connection by opening a session on that very same connection, you'll see that the previous cursors and prep statements will go away.

To check this behaviour, open a session, run a few Sesson.load(), Session.iterate() methods and then call Session.close(). Run the below query and you'll see that the cursors are still there (in the statistic 'opened cursors current').

select n.*,s.* from v$sesstat s, v$statname n where s.statistic#=n.statistic# and sid=23 and n.name like '%cursor%'

However, in the same program, after the above calls, if you
call SessionFactory.getSession() and grab the same jdbc connection from the pool;
as soon as you call Session.load() or Session.iterate(), you'll see that the number of open cursors will be 0 or decrease dramatically. This means that the jdbc driver is smart enough to track the status of the cursor and prep stmt and reports the closed cursors in the next round-trip to the database, hence reducing network round-trips, which is a good thing for performance.

Regards,
Bulent Erdemir

Java primitive types

2006-09-29T17:07:00.000+02:00

Just to remember... nothing more :

byte	Short numerical from -128 to +127	1 byte
short	Short numerical from -32768 to +32767	2 bytes
int	Numerical from -2 147 483 648 to +2 147 483 647	4 bytes
long	Long numerical from -2⁶³ to +2⁶³ -1	8 bytes
float	Decimal from -1.4 * 10^-45 to +3.4 * 10³⁸	4 bytes
double	Long decimal from 4.9 * 10^-324 to +1.7 * 10³⁰⁸	8 bytes
char	Unicode character (65536 possible characters)	2 bytes
boolean	Boolean (true or false)	1 byte

Let's work in full screen mode

2006-09-27T10:09:00.000+02:00

One of the greats features offered by Java is its capability to switch in full screen mode. The following article is a sun's tutorial on this subject :

http://java.sun.com/docs/books/tutorial/extra/fullscreen/index.html

To illustrate how it is benefit to use this mode, I want to opposite it to web based applications that impose the display of unusefull navigator toolbars (taking 25% of the screen workspace).

I will implement full screen mode in Violet UML Editor.

EAI, ESB and SOA news

2006-09-19T10:45:00.000+02:00

when I was young, I developped on webMethods platform. Since this périod, I feel that writing java code is a prehistoric way of programming.

http://www.ebizq.net/

Monitoring tools for Sun Java SE 6

2006-08-18T10:23:00.000+02:00

Here is a good article flying over tools that are usefull to monitor JVM 1.6 :

http://java.sun.com/developer/technicalArticles/J2SE/monitoring/

Monitoring the GC on JVM 1.4

2006-08-11T14:45:00.000+02:00

As JConsole is provided with Java 1.5, Marco sent me a link to open source software that monitors the GC, using the jvm "verbosegc" option.

http://www.tagtraum.com/gcviewer.html

Understanding the garbage collector

2006-08-11T14:41:00.000+02:00

Here is a good article (in french) by Romain Guy explaining how the Sun's JVM garbage collector works and how it is possible to set the GC mode

http://gfx.developpez.com/tutoriel/java/gc/

Memory dumps are usefull

2006-08-10T17:48:00.000+02:00

Here is a JVM option very interesting :
-XX:+HeapDumpOnOutOfMemoryError usefull to identify memory leak responsability

Sun's JVM options : the (big) list

2006-08-10T12:13:00.000+02:00

I just put this link (thanks to Marco) :

http://blogs.sun.com/roller/resources/watt/jvm-options-list.html

I 'll make no comment about the difficulty to tune a virtual machine. Oh.. I would said just a few words : prefer design and don't hope you will tune your quick development that has been quickly deployed in production under preasure.

Inside the Sun's JVM memory

2006-08-10T11:15:00.000+02:00

Yesterday, my manager asked me about a problem concerning the eden space memory. So, this is a summary of JVM's memory management.

Heap Size
The allocation of memory for the JVM is specified using -X options when starting ColdFusion

JVM option Meaning
-Xms initial java heap size
-Xmx maximum java heap size
-Xmn the size of the heap for the young generation

(extended options)
-XX:MaxPermSize maximum permanent generation size (for creating object instances)

For efficient garbage collection, the -Xmn value should be lower than the -Xmx value.

Heap size does not determine the amount of memory your process uses
If you monitor your java process with an OS tool like top or taskmanager, you may see the amount of memory you use exceed the amount you have specified for -Xmx. -Xmx limits the java heap size, java will allocate memory for other things, including a stack for each thread. It is not unusual for the total memory consumption of the VM to exceed the value of -Xmx.

Garbage collection
There are essentially two GC threads running. One is a very lightweight thread which does "little" collections primarily on the Eden (a.k.a. Young) generation of the heap. The other is the Full GC thread which traverses the entire heap when there is not enough memory left to allocate space for objects which get promoted from the Eden to the older generation(s).
If there is a memory leak or inadequate heap allocated, eventually the older generation will start to run out of room causing the Full GC thread to run (nearly) continuously. Since this process "stops the world", ColdFusion won't be able to respond to requests and they'll start to back up.
The amount allocated for the Eden generation is the value specified with -Xmn. The amount allocated for the older generation is the value of -Xmx minus the -Xmn. Generally, you don't want the Eden to be too big or it will take too long for the GC to look through it for space that can be reclaimed.

Stack size
Each thread in the VM get's a stack. The stack size will limit the number of threads that you can have, too big of a stack size and you will run out of memory as each thread is allocated more memory than it needs.
JVM option Meaning
-Xss the stack size for each thread
-Xss determines the size of the stack: -Xss1024k. If the stack space is too small, eventually you will see an exception class java.lang.StackOverflowError .

How to monitor your application

2006-08-09T20:53:00.000+02:00

I just found an article about how to use the JConsole that is included in Java SE 1.5. The article also presents in a few words the JMX phylosophy.

http://java.sun.com/developer/technicalArticles/J2SE/jconsole.html

SwingWeb 1.0 : a new swing to web bridge framework

2006-08-09T17:52:00.000+02:00

Wooh! It's a great day. There's a new framework that allows to publish a swing application on the web. I just put the link here but I will write another message about it. This is really great.

http://swingweb.sourceforge.net/swingweb/

Batch processing in Hibernate

2006-08-08T11:21:00.000+02:00

I read this article that is very interesting (thank you very much Marco) :

Suppose you need to insert 200,000 records into a database in Hibernate. You'll need to adjust the following settings:


//set the JDBC batch size (it is fine somewhere between 20-50)
hibernate.jdbc.batch_size 30

//disable second-lavel cache
hibernate.cache.use_second_level_cache false

//and now do your job like this
Session S=SF.openSession(); //SF = SessionFactory object
Transaction T=S.beginTransaction();
 
for (int i=0;i<200000;i++)
   {
   record r=new record(...);
   S.save(record);
   if(i % 30==0)
           { //30, same as the JDBC batch size
           //flush a batch and release memory
           session.flush();
           session.clear();
           }
  }

//clean 
T.commit();
S.close();

(Author : Anghel Leonard)

Debugging application servers

2006-08-07T15:23:00.000+02:00

Today, I found a great article that explain how to debug remotly several application servers.

Follow this link