I.T. aware » Java

Java BarCamp Paris 4th ed. : Cloud and DDD

Sébastien Letélié — Sun, 05 Apr 2009 19:20:31 +0000

A big success! It was full of people in the great Google’s office. 2 schedules / 4 rooms and a total of 7 sessions, I present the both where I participated :

Cloud computing
Not really a Java subject but it attract people. We tried to define the cloud computing and we fixed that there is 3 offers :

IAAS (Infrastructure as a Service): this is typical Amazon services products, S3 for storage and EC2 for virtualized servers. Amazon offer very basic service now with a very powerful management tool in Eclipse plug-in (see the demo). There is also Elastic Grid proposing to develop and deploy easily on the Amazon infrastructure, GoGrid an Amazon concurrent. I believe that the recent IBM / Sun merge will create new offerings.
SAAS (Software as a Service): we find a lot of solutions (often based on the previous offer), for example Amazon SimpleDB, Amazon SQS, Google Apps, Microsoft Azure Services CloudMQ, ZumoDrive … and I could continue like a long time…
PAAS (Platform as a Service): is hosting the application on a common and scalable platform, it is typically Google AppEngine, it is possible to deploy all yours web application if you know Python. Microsoft probably has a deal in Azure (I should have a look) and Sun has just launched Zembly.

A lot of discussion on what about offline, security, and where is java in the cloud. For me offline mode is really important in a world of increasingly nomad people. Cloud is primarily storage space allowing me to share my data between my devices, then an area of services, and finally deployment platform of my apps.
Finished managing a backup that is never done, losed time finding a way to share data and finally used USB key, now my data are in the cloud and synchronized on all my devices. I have set up Zumodrive in my company and it’s very cool, the documents are shared even outside the company and I don’t care about backup.
Security is the most bigger difficulty for acceptance in the company, I hear the same remarks when talking about the payment on Internet ten years ago. All these services are secure and there is no zero risk.
Java have his place in the cloud on client and server side. The multi platform aspect facilitates the developments on the client (eg: ZumoDrive client is in Java), I want to see more and more Java APIs « cloud-ready » facilitating the integration of service in code. Similarly on the server side I look forward to Google AppEngine in Java.
Finally the advantage of cloud computing is primarily economic, smalls company are the first customers and have found lower cost and flexible capabilities.

DDD (Domain Driven Design)
I had little success at the last barcamp with this subject, this time it was proposed by others much more stronger than me and have made relevant arguments on the benefits of the concept. One of the important point raised we used talking too much technical and framework implementation than focus more on the reality, something that we tend to forget wanting to put our new framework in our code. I talked about Qi4j, that is not pure DDD implementation, but is for me the best way to modelling reality. I want make a demo of my medical record implemented with Qi4j to really prove that this approach is relevant.
Of course I’m convinced that a DDD refactoring of an existing code is difficult. DDD is a best practice and a new way of development vision. Have to follow for sure …

Thank you again to the organizers. It is always a good opportunity to exchange. And i hope Google will open their doors as often as possible;)

JavaCamp II : DB and ESB

Sébastien Letélié — Sat, 20 Dec 2008 21:01:29 +0000

The second edition of Octo‘s Barcamp Java was great. This event format is really interesting because it allows having the opinions of others, learn through their experience and meet interesting people.
Two of my proposals were adopted: RDF+OWL and database.
The subject RDF+OWL has not really been interested and has finished in the more generally REST subject. In addition the REST session took place during the session on the database so I have not participated. I re-suggest it next time, with another title these acronyms were not always known.
What database for what need ? it was the question on which I wanted to talked about. 8 votes have allowed this matter to be debated in a room. But finally 4 responded to the call. The exchange has not been less interesting. This will be the subject of my next post.
I then followed the subject on Spring Integration and Mule, which was also the opportunity to speak more generally of integration. I just give you a list of tools mentioned (I make comments on what I know):

Spring integration : Version 1.0 have been released, this framework is the implementation of the design pattern book EAI Pattern.
JitterBit : an open source EAI with advanced management tool, the GUI is attractive but I have not had time yet to really test the product
OpenAdaptor : First opensource EAI developed by a german team. I personally used to develop an EAI dedicated to health which actually interconnects the SAMU of the Champagne-Ardennes region (3 to 4 messages per minute it’s still reasonable). The product is stable and multi-source design, pipe, sink is well thought out. There is a lot of connectors but not always reusable, it is better to re-develop your own when you have specific features. I used the original version 1.7.2, there was no version 2 but a complete refactoring that is now version 3. An article by the author was published recently in JDJ.
Mule : a lightweight ESB now well known, I have not had the opportunity to implement it, but before the arrival of Spring Integration it was one that interested me most. Nicolas has implemented it and has even made a quickie at DEVOXX08.
OpenESB : implementation of the Sun JBI specification (JSR-208) dedicated to integration
JBoss ESB : ESB by JBoss
Apache Synapse : lightweight ESB of Apache Foundation
Apache serviceMix : ESB, JBI implementation
Apache CAMEL : implementation of EAI pattern (idem Spring integration)
Apache CXF : implementation of JAX-WS.
Axis2 : same but with asynchronous mode and REST. I started working on web services with version 1 of this framework and realize practical training works with it. The architecture allows flexible configuration based on a chain between the request and response. It is simple to use to make an ETL. Version 2 provides asynchronous, more performance and AXIOM to manage attachments (easier to use than SwA)
APMQ : the new specification to standarize messaging tools (initiated by JBoss), it is only the beginning but we have to follow
ActiveMQ : the open source open source MQ, Julien Dubois has some experience on the subject and tells us that we must be wary of some bugged versions (5.0 for example). The tool is not mature and often encounter problems because developers believe they can integrate easily in their application. Apparently this is not as simple as a single jar to add.
OpenMQ : the Sun open source MQ, I could follow the session at the DEVOXX08, it was very broad but Sun show that the project is well supported and adopted by their clients. If I switch to open source (currently i use WebSphere MQ) i think i choose this one.
WebSphere MQ : the historical MQ from IBM that I use now. Robust, mature but hard to configure. Even if IBM provide RCP application for configuration it remains complex. I added the MQ Everyplace module to deploy on mobile handsets, configuration is even more complex. Once it is ready it works well.

Thanks to Luc Bizeul who organize this event and also for the cocktail at the end. I’m waiting for the next

RIA : inside or outside the browser ?

Sébastien Letélié — Wed, 05 Nov 2008 17:12:21 +0000

The Paris JUG this time was devoted to GWT and implementation of Restlet for GWT. Two presentations greatly performed by Didier Girard and Jerome Louvel. I was impressed by the number of participants, thinking that GWT was already in the soul. Bravo to Didier continue to promote this technology and Jerome to put the concept of REST.
Still, I am astonished at the vision that people have of the RIA. For many I have the impression that RIA means rich web application. But the notion of « rich » is simply a reconsideration of the user experience and this does not necessarily by the browser. GWT, Ajax, AppletFX, Flex or Silverlight do not have the monopoly of RIA simply because they run in a browser.
Javascript enabled to overcome the limitations of HTML in the browser and gave a new dimension to Web applications. The browser now becomes a runtime JavaScript and uses HTML as graphics library. Like Java with Swing, C# with WPF or Silverlight, AS3 with Flash and Flex.
iTunes is probably one of the first RIA and this is not a web application. As I said already we must differentiate Rich Web Application and Rich Desktop Application. A RWA runs in the browser, a RDA runs in an OS.
There are advantages and disadvantages in both approaches but the distribution and maintenance which have long been the strengths of Web applications are no longer true today.
As you do more surprised to have your Windows automatically updated it is now also possible for an RDA to be maintained and transmitted via the Web. Java Web Start is a good example and Adobe AIR knows how to do too. But i herer what you say : to run Java or Air, you have to respectively install the JVM and runtime AIR. Yes it’s true like you do it recently when you installed Chrome or previously installed Firefox. The difference is that Windows come with its own browser and when you buy a PC with Windows you have it. At one time you install a runtime and except if you are terribly lazy person you aren’t obliged to be use Windows/IE only.
Where we must be vigilant with a RDA is to not go back to the old client/server model. The RDA must remain a UI layer and not shipping business that must always be server side.
Apple had already experimented this with WebObjects Java Client and continues today to offer similar APIs for Cocoa and now IPhone SDK.
To the slogan « the browser is the platform » I answer « the browser is a platform ». Future architectures should not be dependent on UI layer because it must be developed in the best technology to meet the objectives of application and customer needs by focusing on ergonomics and performance.
Our application ResUrgences is in web for 8 years now in a sector (health) where applications are often client/server. Now the extension from the emergency department to the mobile emergency department (say SMUR in France) forces us to reconsider the web architecture because using a web application on a Tablet PC offline, although not impossible, is not appropriate. Especially when you have to interconnect with monitoring and electro-cardiogram equipment.
So what choice between RWA and RDA ? The first step is to think RIA, so to have a SOA server side architecture and services accessible through various formats via various protocols. At this point different criteria have to be focus on: ergonomics, performance, accessibility, environment (OS and hardware), openness, security, compatibility with existing … So there is no obvious answer. I’m looking for a long time on a table that defines what technology for what needs and now I think it’s impossible.
What should be considered is :

access to local resources (files, applications, USB, serial, Bluetooth) is an argument to look to the RDA. Although this can be remedied with an applet and increasingly with Gears (but it’s a RWA/RDA mix, why not is what I do) and that the Flash plugin already allows access to the camera.
the concept of « push » to send data to a client from the server is now possible with RWA (Comet, reverse Ajax) and soon standarize in HTML 5 (WebSocket).
exchanges via asynchronous MOM with queues client side cannot yet be in RWA. Gears should propose an API and LifeCycle Data Service does not really do it because the queue is server side.
uniformity of application with a single platform deployment independent of the OS is probably the most powerful argument for the SI to choose a RWA

Terracota presentation

Sébastien Letélié — Sun, 05 Oct 2008 13:23:18 +0000

It was a pleasure to show Terracota presentation by its creator Ari Zilka, organized by the very innovative company Zenika.
Terracota is a JVM cluster, it allows to synchronize JVM, based on the principle of NAS but for memory: NAM for Network Attached Memory. Forget serialization session, finished storage state of objects in database, Terracotta allows you to focused on the essentials and reduce dependency with the database. The example showed how to better manage the principle of registering on a web site with email confirmation. The classic method is to store basic identification data with a status and change that status when the email is received. With Terracotta this data remains in memory and is shared by all JVMs, it is stored on database only upon receipt of the email. In addition Terracotta stored on disk the memory status, used to manage a server crash.
For my part, although I am interested in this tool since its creation and i’ve mentioned on this blog when it become open source, I have not implemented yet. Even working on WebObjects the advantage is obvious, in fact Apple had thought it deployment solution for this framework with one JVM launched for each WebObjects application instance. The whole managed by a simple and handy tool: Monitor. The Apple Store is still deployed with this solution. This approach is due to EOF (ORM from NeXT) that has only one flaw: it is not multithread. So for individual instance of application know the status of each other on enterprise objects they use in common, each database access (change, create, delete) is stored in a table that is read by other applications to synchronize their objects. With Terracotta you simply implement the DSO (Distributed Shared Objects) concept on the graph object to share and that’s it. To go even further and be more generic i should implement this on the EOF cache layer like it was done with EHCache and Hibernate. I have to take a serious look on it, this will be a next news with a good example of implementation of Terracotta.

Note that this is the first of a (hopefully) long series of Zenika event, so thanks again and see you next time …

BIRT DESIGNER-Hide/Show a component

Cyril Balit — Wed, 01 Oct 2008 21:48:08 +0000

On a project using BIRT I was confronted with this problem. I generate complex reports using components and datasets defined in a library. I wish to show a component only if the bound dataset contains data.
The operation is simple but I looked for the most generic solution. Indeed the component will be used in some reports and the update operations have to be the simplest as possible.
First of all it is necessary to distinguish two situations:

Dataset that contain only one set of data (characteristics of a customer for example)
Dataset multi-lines (customers list)

I used Birt Designer to configure the various elements.

Dataset with one record

You have to add to the dataset a column which will represents the visible status of the bound component. Edit the dataset properties and create a computed columns by clicking on new

Then you have to set:

The name of the column (isVisible for example)
Its type: boolean

Then you have to build the expression allowing to test the other columns:

Click on fx
Build the expression by testing the wished columns

2. Dataset with multi-lines

First you have to create a computed column with the following attributes:

name : length
Data type : integer
Aggregation : COUNT

We create then an « isVisible » column which test the value of the column lenght with the following expression :

row ["length"]!=0

3. Visible status of the component

In the tab properties and in the visibility column

Select the « Hide element » checkbox
Set the expression field with the value: ! Row [" isVisible "]

If the return value is true the component is not display in the report.

REFACTORING…..to read absolutely

Cyril Balit — Thu, 25 Sep 2008 15:36:21 +0000

A small ticket to speak about this great book of Martin Fowler: Refactoring Improving the Design of Existing Code

I like the way he has written it. The concepts are well explained and the examples are rather simple but also rather close to the reality so that they can quickly be transposed in our daily work.

Just read it…..

Go back to JavaFX

Sébastien Letélié — Sun, 14 Sep 2008 16:38:38 +0000

In a previous post i said JavaFX lack was a design tool to promote a good relationship between developers and designers, essential for membership of the community around this technology. Knowing that designers will not change tools easily the best approach would be to make a bridge between the existing design tools and JavaFX. That is the purpose of Project NILE by offering a Illustrator and Photoshop plugin to export a FXD or a FX file but also a SVG converter and a graphic viewer.
It’s the good strategy i think, so I realized a test.

To enhance collaboration designer / developer I went looking for graphic work on the net, I found « glossy » buttons proposed in .ai and .svg.

The SVG test was not good, the conversion did not include the effects and a lot of corrections were needed to compile. I continued with a conversion via Illustrator. The first shot will not compile because I am european . In the second time it compiles and the result is almost identical to the .ai document. Just a slight color problem quickly corrected.
The FX script is composed of a set of SVGPath, each character of the keyboard is also defined in a SVGPath. A little difficult to operate as it would be more practical to extract a component and to apply behavior as typically a mouse click and passing it in setting its position and character to display.
I extract in script the definition of a button I replace the SVGPath character by a Text component. I add a click event on the mouse and I change the effect when the mouse button is pressed.

GlassButton.fx

packagetestfx1;
import javafx.scene.*;

import javafx.scene.geometry.*;

import javafx.scene.image.*;

import javafx.scene.paint.*;

import javafx.scene.text.*;

import javafx.scene.effect.*;

import javafx.input.MouseEvent;

import javafx.scene.transform.*; 

public class GlassButton extends CustomNode {

    public attribute letter:String;

    public attribute onClick:function(t:String):Void;

    public attribute x:Integer;

    public attribute y:Integer;

    protected function create() : Node {

        var effect = DropShadow { offsetX:0.0,offsetY:1.0,color:Color.BLACK,radius:8.0};

        return Group {

            translateX: x

            translateY: y

            content: [

                SVGPath {

                    effect: bind effect

                    fill: LinearGradient{proportional: false startX: 21.00 startY:35.00 endX: 21.00 endY: 5.00 stops: [

                            Stop {offset: 0.000 color: Color.rgb(0xd2,0xd2,0xd2,1.0)},

                            Stop {offset: 0.500 color: Color.rgb(0x4e,0x4e,0x4e,1.0)},

                            Stop {offset: 1.000 color: Color.BLACK},

                        ]}

                    content: "M36.00,27.00 C36.00,31.42 32.42,35.00 28.00,35.00 L14.00,35.00 C9.58,35.00 6.00,31.42 6.00,27.00 L6.00,13.00 C6.00,8.59 9.58,5.00 14.00,5.00 L28.00,5.00 C32.42,5.00 36.00,8.59 36.00,13.00 Z "

                },

                SVGPath {

                    fill: Color.GRAY

                    content: "M34.00,22.77 L8.00,22.77 L8.00,14.00 C8.00,9.86 11.55,6.50 15.92,6.50 L26.08,6.50 C30.46,6.50 34.00,9.86 34.00,14.00 Z "

                },

                Text {

                    fill: Color.WHITE

                    font: Font { 

                        size: 18 

                        style: FontStyle.BOLD

                    }

                    x: 14, y: 27

                    content : letter

                }

            ]

            onMouseClicked: function( e: MouseEvent ):Void {

                onClick(letter);

            }

            onMousePressed: function( e: MouseEvent ):Void {

                effect = null;

            }

            onMouseReleased: function( e: MouseEvent ):Void {

                effect = DropShadow { offsetX:0.0,offsetY:1.0,color:Color.BLACK,radius:8.0};

            }

        };

    }

}

Then I create a second class will manage the position of keys looping over an array of characters.

Keyboard.fx

packagetestfx1;
importjavafx.scene.*;
importjavafx.scene.text.*;
importjavafx.scene.paint.*;
public class Keyboard extends CustomNode {

    public function create():Node {

        java.lang.System.out.println("BuildLetters …");

        var t:String;

        var letters = [

            "A", "B", "C", "D", "E", "F", "G", "H", "I",

            "J", "K", "L", "M", "N", "O", "P", "Q", "R",

            "S", "T", "U", "V", "W", "X", "Y", "Z", "@"

        ];

        var buttons:Node[] = [

            Text {

                font: Font { 

                    size: 14 

                    style: FontStyle.PLAIN

                }

                x: 5, y: 16

                content: bind t;

            }

        ];

        var posX:Integer = 0;

        var posY:Integer = 0;

        var incI:Integer = 0;

        var incJ:Integer = 0;

        for (i in letters) {

        if (

            incI mod 9 == 0) {

                posY = 35 * (incJ ++ ); 

                posX = 0;

                incI = 0;

            } else {

                posX = 35 * incI;

            }

        insert GlassButton {

                x: posX

                y: bind 45 + posY

                letter : i

                onClick : function(s:String) {

                    t += s;

                }

            } into buttons;

        incI++;

        }

        java.lang.System.out.println("OK.");

        return Group {

            content : buttons

        }

    }

}

And then I put it all into an Applet following James Weaver advise.

GlassButtonApplet.fx

packagetestfx1;
importjavafx.application.*;
importjavafx.scene.*;
importjavafx.scene.text.*;
importjavafx.scene.paint.*;
Application {

    stage: Stage {

        content: Keyboard {}

    }

}

Below the result, click on the keys and put the Applet out of the browser by pressing the Alt key and dragging the Applet. The launch time is long be patient (30s), I don’ t know why right now, I will ask Sun.

Note: being able to put the Applet off the browser, it require to create a JNLP and therefore to sign all jars depending on the applet. A little boring, it is necessary to automate this task:

certificate creation: keytool-genkey [-keystore ]-alias
JAR signing: jarsigner [-keystore ] . jar

Conclusion
By putting all the time spent in developing it take about 4 hours, including learning of JavaFX. This is correct but it would be nice to further reduce this time. I believe that it is difficult to manipulate JavaFX without at least one real-time viewer. One provided in NetBeans 6.1 is a little slow.
Finally, the idea is there and it is promising because with the Java Plugin to 4MB will finally have rich full Java apps that take advantage of being able to do more than the competition: access to serial devices, Bluetooth, … on the client, using existing Java APIs (eg JMS), switch to desktop app…

Composite oriented programming

Sébastien Letélié — Sun, 24 Aug 2008 14:53:15 +0000

What lack in the object-oriented programming to invent a new concept ? According to Rickard Öberg, best practices and design patterns are not completely respond to all modelling problematics. The domaine driven design shows that the objects have different behaviour according to the contexts in which they are used. An object model must be adaptable in the environment where it live. Although a domain defined a set of common business objects their operation and behaviour expected changes as applications needs. To meet this expectation Rickard Öberg and Niclas Hedhman have developed a framework: Qi4j (chee for jay). Based on the concepts of AOP, DI and DDD, they developed the composite approach implemented entirely with Java 5.

The framework isn’t finished yet, but the idea is really interesting and extends existing concepts implemented in Improve Foundation and Spring (dependency injection, inversion of control). We find the layer concept (one advantage of IF vs Spring) but also module and assembly. The Composite is an object composed of different « Fragments » which can be

« Mixins »: a set of implementation of interfaces,
« Concerns »: method interceptor (concept of the AOP)
« Constraints » : constraints on method input / output (concept of design by contract)
« SideEffects » : action not really linked to the object, which can be reused by different objects

The advantages are mainly a model much business closer that responds well to Eric Evans’s DDD concept. The drawbacks still learning and therefore adoption. Finally remains about the performance, which is not yet done. I do not think this is a competitor to Improve Foundation or Spring but rather a complement to which we will have an interest.

Qi4j : the documentation is still being developed but the concepts are well presented

DDD presented by Eric Evans in two parts:

Java 6 update 10

Sébastien Letélié — Sat, 12 Apr 2008 08:58:59 +0000

The Java 6 update 10 will be special. This future release provide features to keep Sun in the RIA competition, like Ethan Nicolas said, without waiting the version 7 :

Difficult to detect JREs, especially from a web browser
Difficult to automatically install new JREs
Large download size
Poor cold start performance
Little overlap between applets and Web Start programs

3 importants new things :

Java Kernel
Java PlugIn
Java Deployment Kit

Groovy and DSL

Sébastien Letélié — Thu, 06 Dec 2007 22:39:53 +0000

We were lucky receiving Guillaume Laforge at Improve for a Groovy and DSL presentation.
I didn’t have time to really study script languages, i just take a quik look on Scala and Groovy and not on JRuby and Jython. I worried about the capacity of the developers to debug with this languages. I had a lot of problems with Javascript. We were agree with Josh Marinacci in our last exchange to say that this technology is really interesting but how we can control it. Guillaume put me at rest it’s not really a problem, developers don’t make really more mistakes than they do in Java, and now IntelliJ have a great plugin which manage debugging, color syntaxing, content assist, refactoring… The Eclipse plugin haven’t it yet but it comes.
It’s clear Groovy is a really great tool to realise DSL. The syntax is malleable and readable. His extension capacity with category concept (like in Objective C) or with operators is really great.
I forgot to ask him what’s he thinking about JavaFX. The Chris Oliver‘s DSL to create Swing UI is not based on Groovy for this reason, is it a good reason ?
For your information Guillaume has created a company G2one offering services around Groovy and Grails. The slides he shows us are available on grails-exchange. Guillaume will be at JavaPolis.
Thank’s a lot Guillaume and see you soon