Paul Bakker

Open source, free Community Edition of IntelliJ

Paulb — Thu, 15 Oct 2009 21:10:00 GMT

Jetbrains has open sourced IntelliJ, my favorite IDE. Besides that, they introduced a free Community Edition. The Community Edition is a stripped down version of the full product. Most of the JavaSE (and other languages such as Groovy and Scala) are available, but all JEE stuff (even simple web projects) are not. Check out the comparison matrix.

While I do like the introduction of the free edition because it will help spreading IntelliJ, I wonder how many people can actually use it when all enterprise functionality is removed. Eclipse has WTP for developing web projects. To my opinion it's by far not as good as Intellij's web/JEE functionality, it's still free.

For basic Java coding, I don't really see the advantage of IntelliJ, both IDEs are good at it. The advantage is in the support for frameworks and JEE. I wish Java developers would stop making a big deal of having to pay for something, specially when it's very reasonable priced.

The list of features of the upcoming version 9 is very impressive by the way. A lot of the new JEE 6 technology is supported already and Grails support is getting more and more impressive.

Testing Grails REST services

Paulb — Thu, 20 Aug 2009 15:06:00 GMT

Unit Testing in Grails is very easy. If you are not familiar with this, you should definitely check out the reference manual about it. Today however, I was writing some REST services that return XML. The controller does content negotiation and can, depending on the request, return HTML or XML. Of course I also wanted to write a test for it, but I couldn't find how to do it in the documentation. It turns out to be very easy, but I wanted to share how I did it.

First a simple version of a controller that supports content negotiation:

def list = {
    def myContact = new Contact(firstname: 'Paul', lastname: 'Bakker')

    withFormat {
      html {
        [contact: myContact]      
      }

      xml {
        render(contentType: "application/xml") {            
            contact {
              firstname(myContact.firstname)
              lastname(myContact.lastname)
            }
        }
      }
    }
  }

The withFormat block chooses, depending on the request, the response to build. If this controller is requested with a normal URL from a browser, HTML will be returned. If the Accept header is set, or if the URL is postfixed '.xml', XML will be returned however. This is all documented well in the reference documentation, so you can read the details there. If the controller is requested for XML, the following XML will be returned:

<contact>
   <firstname>Paul</firstname>
   <lastname>Bakker</lastname>
</contact>

Next I wanted to write a Unit Test for this controller. There are two special things about testing a controller that does content negotiation:

Request the correct content type
Test if the response is generated correctly

For the first step you should first understand how the controller figures out what content type to return. When Grails processes a request, it will check both the Accept header and the URL extension (note that the Accept header is not enabled by default!). It will set a variable request.format with the value that is defined in the mime.types configuration in Config.groovy for that request format. So concluding, you'll need to set the request.format variable in the test, which is very easy.

controller.request.format = 'xml'

Note that the controller variable in the example is the implicitly created controller by the ControllerUnitTestCase.

Next you should invoke the controller and check the XML returned by the controller. This is what I couldn't find in the documentation. After invocation you can access the response using:

controller.response.getContentAsString()

This contains the XML as a String, which you can parse using XmlParser. Easy! The complete test is displayed below. Note that only the XML request is tested. You should add another test to test the HTML response.

void testListInXML() {
    controller.request.format = 'xml'

    controller.list()

    def contact = new XmlParser().parseText(controller.response.getContentAsString())
    assert contact.firstname.text() == 'Paul'
    assert contact.lastname.text() == 'Bakker'

  }

JavaFX 1.2 example: Folder Visualizer

Paulb — Mon, 17 Aug 2009 14:22:00 GMT

Last year I blogged about a small JavaFX project I implemented called Folder-Visualizer. The tool lets you find large files and directories to effectively clean your hard disk. The previous version of the tool was implemented with an early beta of JavaFX. I reimplemented it with JavaFX 1.2, now using standard components, charts and background tasks. I will show some of the code to give an idea what it takes to implement a real application with the current version of JavaFX.

Charts

In a previous post I blogged about the new charting components in JavaFX 1.2. They are easy to use. Common functionality such as rendering from a sequence of data and clicking on a part of the chart is all supported, and they look ok too. In the PieChart there is a very annoying rendering error however (the black line at the left top) which is always there. And while I think the charts look good, they are nowhere near the looks of the Flex charting components yet...

Temporarily adding nodes

Sometimes you want to add a node temporarily. For example, when this app is indexing, the chart is removed and a ProgressIndicator is displayed. As soon as the indexing process is finished, the ProgessIndicator is removed again and the new chart is added to the scene. The easiest way to remove a node is by using it's id. You can give a node an id by setting the id property, which is a String. Next you can use the "lookup" function on Scene. This is very much like the "getElementById" method in JavaScript, and you can use it the same way. So to remove the chart (id: "chart") you can use the following code:

delete scene.lookup("chart")  from scene.content;

Also remember that the scene's content is just a sequence. This means you can easily add nodes on the fly too, for example:

  insert ProgressIndicator {
             id: "progress"
             progress: -1;
             translateX: 300
             translateY: 400
             scaleX: 10
             scaleY: 10
           } into scene.content;

Binding to Java

The actual scanning and indexing of directories is implemented in Groovy. The Groovy classes are simply packaged in a JAR file, and the JAR file is used from JavaFX. JavaFX can call any Groovy code without a problem, but some extra work was still necessary. The Groovy classes return a java.util.List with the indexing information. JavaFX can use lists, but you can't use binding on it. The following code for example will not compile:

 var list = new ArrayList();
    list.add("Str1");
    list.add("Str2");

    var seq = bind for(item in list) {
        item;
    }

This can be partly solved by transforming the List into a Sequence yourself (example below) so you can at least use binding and sequence syntax in the rest of the code, but you still need to update the sequence yourself when the List is changed.

function createSequence(list : List) : FolderItem[]{
    var items : FolderItem[] = [];

    for(item in list) {
        insert item as FolderItem into items;
    };

    return items;
}

While this might look like a problem, it's just a inconvenience. It's great that JavaFX call Java. This feature alone makes JavaFX more interesting than AIR, where your whole app must be ActionScript. While I don't mind writing the UI in a new (less mature) language, I don't want to write all my code in it.

Strange binding bug?

I did run into some strange error at some point. As you might have noticed in the code of the BreadCrum, I use a bind for color while this is already in a bound context. To me this seems unnecessary. However if I remove the bind, the application still works correctly, but also shows a warning at the command line, telling that a node was added to a Group while not removed from it's old Group. I can't explain it at this moment, and to me it seems like a bug.

Talking about bugs, I found that a lot of bugs are fixed in version 1.2. In previous versions I did still sometimes run into, often binding related, bugs. Besides this error everything worked exactly as expected.

Using FileChooser

JavaFX doesn't have a FileChooser component. You can use the Swing JFileChooser without any problem however, and it doesn't compromise rendering since a native window is used anyway.

var fc = new JFileChooser();
fc.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);

var retVal = fc.showOpenDialog(null);

if(retVal == JFileChooser.APPROVE_OPTION) {
   dirNameInput.text = fc.getSelectedFile().getAbsolutePath();
}

Executing background tasks

Another new feature in JavaFX 1.2 is support for background task execution. In the Folder-Visualizer application the indexing can potentially take a long time, and you don't want the interface to freeze as soon as indexing starts. The indexing should run in a separate thread obviously. JavaFX has the JavaTaskBase class that is similar with Java's Callable. You need to override the "create" function that returns a RunnableFeature. The RunnableFeature contains the real work, and can be implemented in Java. When the task is done, you probably want to change something in the UI. Similar to Swing programming you can use a method "Entry.deferAction(Runnable)" to run code on the UI thread. The code that will run on the UI thread is a callback.

Confused yet? It took me a minute to grasp it. Three extra classes to just execute a piece of Java code on the background. While it's an elegant solution, it's still feels like a lot of work. So to summarize you'll need the following

A task description (written in JavaFX, extends JavaTaskBase)
A RunnableFuture implementation (written in Java, implements RunnableFuture)
A callback interface (so that Java can call JavaFX)

I will show the implementation of each class, and the code that actually starts the task.

Task Description

public class VisualizeTask extends JavaTaskBase{
    public var dir : String;
    public var callback : FXListener;

    public override function create() {
       new VisualizeFuture(dir, callback);

    }

}

RunnableFuture implementation

public class VisualizeFuture implements RunnableFuture {

    private final FXListener listener;
    private final String dir;
    

    public VisualizeFuture(final String dir, final FXListener listener) {
        this.listener = listener;
        this.dir = dir;       
    }

    public void run() throws Exception {
        Folder folder = new Folder(dir);
        FolderVisualizer visualizer = FolderVisualizer.create(folder);
        final List<FolderItem> items = visualizer.toVisualize(folder, 5);

        Entry.deferAction(new Runnable() {

            public void run() {
                listener.callback(items);
            }
        });
    }
}

Callback interface

public interface FXListener {
    public void callback(List<FolderItem> items);
}

Executing the task

 var visualizeTask = VisualizeTask {
        dir: dirNameInput.text
        callback: FXListener {
            override function callback(ret : List) : Void{                
                createChart(createSequence(ret));
            }
        }
    };

Downloading Folder-Visualizer and check the code

The Folder-Visualizer is hosted at Google Code: http://folder-visualizer.googlecode.com. You can install the application by simply clicking the JNLP file, it will install as Webstart application. Besides the JavaFX version, there is a AIR version developed by Jamie Craane.

VMware acquires SpringSource

Paulb — Tue, 11 Aug 2009 07:41:00 GMT

Interesting news today; SpringSource is acquired by VMware. Rod Johnson will continue to lead SpringSource however. The idea behind the merge is extending the Spring stack with deep support for virtualization. There is no product overlap between the two companies, and licenses are not going to change according to Rod Johnson. While VMware is not a company that I expected to be interested in a company like SpringSource, it does make a lot of sense. I feel like this will truly result in a better full-stack experience, so I can't wait for hearing more details about new products etc!

Read the original blog post here.

JavaFx Charts

Paulb — Fri, 10 Jul 2009 14:03:00 GMT

One of the really cool things in the JavaFx 1.2 release are the addition of Charts. The charts look great but the documentation is far from sufficient. So I wrote down this post to help out a little.

Pie chart

Lets start with a pie chart. The most important part of a pie chart definition is the sequence of data. For the example chart, there are three PieChart.Data instances in the data sequence. Netbeans' code completion doesn't really work anymore when working on inner classes (such as PieChart.Data) so don't expect to get any help from the IDE. Each data point must specify a value (the percentage of the section), the fill (color of the section) and a label.

PieChart {
            title: "Language Popularity (Tiobe Index)"
            data: [
                PieChart.Data {
                   value: 20.452                   
                   label: "Java"
                }

                PieChart.Data {
                   value: 4.530                   
                   label: "C#"
                }

                PieChart.Data {
                   value: 10.419
                   label: "C++"
                }

                PieChart.Data {
                   value: 17.319
                   label: "C"
                }

                PieChart.Data {
                   value: 9.269
                   label: "PHP"
                }

                PieChart.Data {
                   value: 7.789
                   label: "Visual Basic"
                }

                PieChart.Data {
                   value: 100 - 20.452 - 4.530 - 10.419 - 17.319 - 9.269 - 7.789
                   label: "Other"
                }
            ]
        }

The 3D version of the chart works exactly the same, just use the PieChart3D class instead.

Scaling

For scaling a chart you can simply use the scaleX and scaleY properties. Rendering will be smooth even when you scale to large values because the charts are drawn directly, no pictures are used.

Bar chart

Next where going to look at the bar chart. A bar chart's data (BarChart.Data) is grouped in series (BarChart.Series). Take the following chart as an example, it shows the top 6 of the Tiobe index.

In this chart there are two series: 2008 and 2009. Each series contains data for each language. The names of the series will be rendered in the legend. The languages are specified in the categories property of the CategoryAxis. The bounds of the value axis is specified in the valueAxis.

 BarChart {
        categoryAxis: CategoryAxis {
            categories: ["Java", "C", "C++", "PHP", "Visual Basic", "C#"]
        }
        valueAxis: NumberAxis {
            lowerBound: 0
            upperBound: 25
            tickUnit: 20
            label:"Rating (%)"
        }
        data: [
            BarChart.Series {
                name: "2008"
                data: [
                    BarChart.Data {
                        value: 20.452 + 0.89
                    }

                    BarChart.Data {
                        value: 17.319 - 1.37
                    }

                    BarChart.Data {
                        value: 10.419 + 0.27
                    }

                    BarChart.Data {
                        value: 9.269 + 0.26
                    }

                    BarChart.Data {
                        value: 7.789 + 2.66
                    }

                    BarChart.Data {
                        value: 4.540 - 0.54
                    }
                ]
           }

           BarChart.Series {
                name: "2009"
                data: [
                    BarChart.Data {
                        value: 20.452
                    }

                    BarChart.Data {
                        value: 17.319
                    }

                   BarChart.Data {
                        value: 10.419
                    }

                     BarChart.Data {
                        value: 9.269
                    }

                    BarChart.Data {
                        value: 7.789
                    }

                    BarChart.Data {
                        value: 4.540

                    }
                ]
            }

        ]
    }

The 3D version of the bar chart works exactly the same again.

Line chart

Next is the line chart. Just like the bar chart, a line chart's data is divided into series. Each serie defines values for a line on the graph. In the example graph there are two; one for the temperatures in 2008, and one for 2009. It's important to first specify the upper and lower bounds of the xAxis and yAxis. If you don't, your graph won't display anything. Also set the ticketcount for the xAis correctly. In the example code you'll also see that I specified a formatTicketLabel funtion. This function is used to create String values of each value.

All there is left is specify the data points for the graph. You only need to set the value property.

LineChart {
        title: "Daily mean temparatures in July (data from KNMI)"
        xAxis: NumberAxis {
            tickUnit:1
            lowerBound:8
            upperBound: 12
            label: "Day (in July)"
            formatTickLabel: function(val) {numberFormatter.format(val)}
        }

        yAxis: NumberAxis {
            lowerBound: 0
            upperBound: 30
            label: "Temperature"
        }

        data: [
            LineChart.Series {
                name: "2009"
                data: [
                    LineChart.Data {
                        xValue: 8
                        yValue: 15.6
                    }

                    LineChart.Data {
                        xValue: 9
                        yValue: 15.1
                    }

                    LineChart.Data {
                        xValue: 10
                        yValue: 14.4
                    }

                    LineChart.Data {
                        xValue: 11
                        yValue: 16.6
                    }

                    LineChart.Data {
                        xValue: 12
                        yValue: 17.5
                    }
                ]
            }

            LineChart.Series {
                name: "2008"
                data: [
                    LineChart.Data {
                        xValue: 8
                        yValue: 14.7
                    }

                    LineChart.Data {
                        xValue: 9
                        yValue: 15.6
                    }

                    LineChart.Data {
                        xValue: 10
                        yValue: 16.9
                    }

                    LineChart.Data {
                        xValue: 11
                        yValue: 16.6
                    }

                    LineChart.Data {
                        xValue: 12
                        yValue: 15.0
                    }
                ]
            }
        ]
    }

Bubble chart

The last chart is the bubble chart. The bubble chart is similar to the line chart, but introduces a third series of values. For the example graph I used the sunshine duration. This third series of data is displayed as a bubble. The bigger the value, the bigger the bubble. This value is specified in the BubbleChart.Data radius property.

BubbleChart {
        scaleBubbleRadiusUsingAxis: false

        
        title : "Daily mean temparatures in July (data from KNMI)"
                xAxis : NumberAxis{
                    lowerBound: 7
                    upperBound : 13
                    label: "Day"
                    visible: true
                    axisStrokeWidth: 1
                    tickUnit : 1
                    tickLabelsVisible: true
                   


                }
                yAxis : NumberAxis{
                    lowerBound: 0
                    upperBound : 30
                    tickUnit: 1
                    label: "Temperature"
                    visible: true
                    tickLabelsVisible: true
                   
               }

        data: [
            BubbleChart.Series {
                name: "Sunshine duraction in 0.1 hour"

                data: [
                    BubbleChart.Data {
                     xValue: 8
                     yValue: 15.6
                     radius: 47
                   }

                   BubbleChart.Data {
                     xValue: 9
                     yValue: 15.1
                     radius: 69
                   }

                   BubbleChart.Data {
                     xValue: 10
                     yValue: 14.4
                     radius: 16
                   }

                   BubbleChart.Data {
                     xValue: 11
                     yValue: 16.6
                     radius: 57
                   }

                   BubbleChart.Data {
                     xValue: 12
                     yValue: 17.5
                     radius: 45
                   }
                ]
            }
         ]
        }

You can run the demo as a Webstart application.

JavaOne - JavaFX 1.2 released

Paulb — Thu, 04 Jun 2009 20:27:00 GMT

JavaFX 1.2 is available now and I'm very impressed. First of all, I didn't expect any release before the end of this year. I was hoping for a preview/beta release here at JavaOne with new components and layout managers. Instead there is a full release, with even more than I was hoping for.

Most importantly:

Components

Finally some real JavaFX components. No wrapped Swing components, but full JavaFX components. The most important components are now included, such as a scrollbar, sliders, progress bars and a list component. Still basic (no fancy datagrid for example), but enough to be used seriously. All of the components are supporting CSS, which enables you to easily change the look & feel of your application just using standard components.

Charting

Besides all the standard components, some charting components are available. Again, all fully supporting CSS, and the API looks nice you use.

Layout

The lack of layout managers was another important problem in the previous release. You were basically left calculating sizes and positions manually which is not very pleasant. First of all the way component sizes are calculated by a container is improved. Next they created some standard layout components. The containers are still simple (compared to the Swing layout managers), but they do the basic magic that's required for most applications. I was also happy to hear that the HBox and VBox are no working properly, which have cost me a few too much hours working around in the previous release.

Great work by the JavaFX team, I'm impressed by the work done in just a few months.

JavaOne day one - JDK 7, JEE 6, JavaFX 1.2 and an appstore

Paulb — Wed, 03 Jun 2009 17:41:00 GMT

The first general session started with some exiting news. JDK 7, JEE 6 and JavaFX 1.2 are available now. Surprising, because half of the JEE 6 specs are not final yet and JDK 7 is far from finished. Later on the day the announcement doesn't quite stand. JEE 6 will be released september, and JDK 7 somewhere next year. Besides the usual "we are big companies and like each other" content there were two real announcements. First of all there will be a Java appstore, which enables you to sell your own Java and JavaFX applications. Besides the fact that it feels very much an Apple appstore rip off, it actually is very interesting. They are not quite there yet however because they decided to first put the appstore online with no possibility to pay for applications. They want feedback to decide how the payment model is going to work. A stupid decision to my opinion. If you can't make money writing applications, there is not enough push behind it to get this thing popular. It still is interesting though. Reading between the lines this secures JavaFX's position too. JavaFX is crucial for the appstore's success.

Everybody was waiting for some Oracle news of course, but that's still under strict rules, so nothing really new about that. Reading between the lines once again, it seems not that much is going to change at first, and another hint that JavaFX is not going to disappear. Happy about that :-)

The JEE6 specs are looking really good. I'm specially happy with EJB 3.1. The 3.0 spec was good, but some things were missing (such as a decent timer implementation). The 3.1 spec doesn't really add anything revolutionary, but EJB 3 now feels finished and complete.

Getting started with JEE 6 - EJB 3.1, JSF 2.0 and JAX-RS on GlassFish V3

Paulb — Sun, 15 Mar 2009 16:24:00 GMT

JEE 6 is almost there. The final version is expected to be released at JavaOne this year, which is the first week of June. So this is a good moment to try out the new features. Let's first see what's new in JEE 6. After that I will show how to install the new APIs to try them out yourself. To me the most important changes in JEE 6 are the following:

-WebBeans
-EJB 3.1 (Lite)
-JSF 2.0
-JAX-RS
-Servlet 3.0
-JPA 2.0

JEE 6 also introduces the concept of profiles. A profile defines a subset of JEE to be more lightweight and focussed to a specific application type. The only profile at this moment is the web profile. THe web profile will probably be supported by containers such as Tomcat, enabling you to use JEE web technology including EJB Lite, without the need for a full blown app server.

Intstalling EJB 3.1 Lite, JAX-RS and JSF 2.0
The easiest way to get started with JEE 6 is using Glassfish V3. The next version of Glassfish will be released together with JEE 6. After downloading Glassfish you should start the update tool. This tool helps you to easily add features to Glassfish. At this moment, EJB 3.x is not fully supported by Glassfish. Only EJB Lite is supported, which is fine for now. EJB will be fully supported in the final release. Installing EJB Lite and JAX-RS is as easy as selecting them in the update tool and click the install button. Installing JSF 2.0 needs a little trick however. In the list you'll see JSF, but it only enables you to update to the next minor update which is 1.2.x. There is no option to upgrade to 2.0. You can solve this problem by first de-installing JSF. After that, you'll find a JSF 2.0 option in the list.

Usage in NetBeans 6.5
In Netbeans you should now create a Web project. That's right, you shouldn't create a Enterprise Project. If you do, you'll find that it can't be deployed to GlassFish V3. The whole application including EJB Lite Session Beans will be deployed as a WAR file.
Trying out JAX-RS and EJB 3.1 Lite
I started trying out features by creating a RESTful service using JAX-RS. I was hoping that EJB3 style injection would be fully supported by now, but it isn't. You still can't use @PersistenceContext to get hold of a EntityManager. There's still a lot of discussion going on to what degree this must be supported, but I'm really hoping it will make the final release. JAX-RS will be a lot more usable when injection of EJB Session Beans and EntityManagers works.

There is an easy work around however. Using the new type of JNDI names, Global Names, it's easy to find a EJB 3.1 Lite Session Bean. Session Beans do support injection, so all JPA code can be delegated to the Session Bean. The lookup of the Global Name works like this:

PhoneService s = (PhoneService) new InitialContext().lookup("java:global/MobileShopServices/PhoneService");

The name is structured as follows: java:global/ApplicationName/BeanName.
The Session Bean is created as a EJB 3.1 Lite Session bean.

        1: @Stateless 

       2: public class PhoneService {  

       3:    @PersistenceContext 

       4:    private EntityManager em; 

       5:     

       6:    public List<Phone> getPhones() { 

       7:       List<Phone> phones = em.createQuery("from Phone p").getResultList(); 

       8:       return phones; 

       9:    } 

      10: }

As you can see, there is no interface. Interfaces are now optional for Session Beans. Not something you would always want, but I see it's use for Session Beans used as JSF backing beans (as used in Seam). Injection works well however.

So the only thing to left to do from the JAX-RS resource is call the Session Bean and return it's result as XML. The full method is implemented as follows:

       1: @GET 

       2: @Produces("application/xml") 

       3: public PhonesConverter getXml() { 

       4:    try { 

       5:       PhoneService s = (PhoneService) new InitialContext()

       6:         .lookup("java:global/MobileShopServices/PhoneService"); 

       7: return new PhonesConverter(s.getPhones()); 

       8: } catch (NamingException ex) { 

       9: Logger.getLogger(PhoneResource.class.getName()).log(Level.SEVERE, null, ex); 

      10: throw new RuntimeException(ex); 

      11:  } 

      12: }

It uses a converter class to convert a list of JPA Entities to XML. The converter basically adds JAXB annotations to the classes.

       1: @XmlRootElement(name = "phones")

       2: public class PhonesConverter {

       3:     private List<PhoneConverter> phones;

       4:  

       5:     public PhonesConverter() {

       6:     }

       7:  

       8:     public PhonesConverter(List<Phone> phones) {

       9:         this.phones = new ArrayList<PhoneConverter>();

      10:         for(Phone phone : phones) {

      11:             this.phones.add(new PhoneConverter(phone));

      12:         }

      13:     }

      14:  

      15:     public List<PhoneConverter> getPhones() {

      16:         return phones;

      17:     }

      18:  

      19:     public void setPhones(List<PhoneConverter> phones) {

      20:         this.phones = phones;

      21:     }    

      22: }

That's all there is to it :-)
There's a lot more to tell about JAX-RS and EJB 3.1 (lite), but I'll get to that in a later post.

JSF 2.0
After JSF 2.0 is installed on GlassFish, you can start to use it immediately. The only thing you'll have to do to tell the container that you're doing JSF 2.0 is change the scheme location of the faces-config.xml.

       1: <faces-config xmlns="http://java.sun.com/xml/ns/javaee"

       2:     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       3:     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 

       4:         http://java.sun.com/xml/ns/javaee/web-facesconfig_2_0.xsd"

       5:     version="2.0">

After doing that, you can use @ManagedBean to create Managed Beans and you can use Facelets without any installation or configuration. There's a lot more to tell about JSF 2.0 but i'll go into more details in a later post.

There seems to be no easy way to install WebBeans in GlassFish yet. I'll try to get it working anyway and report on that too.

JavaFX Christmas greeting

Paulb — Sun, 21 Dec 2008 22:06:00 GMT

I made a JavaFX version of the Christmas card from my company. Basically I separated the picture into four parts, and made each part clickable. When you click, it will zoom in. Simple, but it looks ok. At this moment I can't directly post applets at the blog, so check it out here . The code is just two files, the scene itself and the component for showing each image.

main.fx

ImageDisplay.fx

Live from Devoxx - JavaRebel, zero turnaround development

Paulb — Fri, 12 Dec 2008 17:00:00 GMT

Yesterday's latest talk was about zero turnaround development in Java. I mainly attended the session because I really, really hate waiting for the tedious deploy cycle after changing some code. It's one of the main reasons I believe Grails works so efficient compared to most other web frameworks (even while Grails doesn't do real hot swapping code). The session was extremely well structured. First the turnaround problem was explained including the technical difficulties. More interesting where the reasons why the turnaround problem is so painful. Besides the actual time you spend waiting each week, it also completely disrupts your 'flow'. Costing much more time to get back into your work. The fact that quality of work is probably also hurt a lot was not even covered, but I'm sure this will even be a big factor too. Seams to be another good reason to go for a more lightweight development approach...

Next some basic solutions where covered (which can be used with standard tools), which can make live a lot better but are still not a full solution. At last JavaRebel was covered. JavaRebel is a commercial tool, but is very reasonable priced (it's actually really cheap). JavaRebel install's an agent into the VM, enabling to hotswap almost all type of code changes without any restart or re-initialization required. It's truly amazing. It's even more amazing that you don't have to do anything to get this behavior, other than enabling the agent. It event supports deeper support for a few frameworks, including Spring, to hot swap configuration files.

After showing JavaRebel a short demo was shown about a new tool of the company. It's sort of a server runtime that enables you to hot upgrade and downgrade applications without ever going down. This was even proofed during the session by upgrading a chat application that was running at that very moment in the conference room. Not a second of downtime. The only thing I was thinking about after the session was: I want this. I'm going to try out JavaRebel and probably going to get a personal license.

Live from Devoxx - Spring 3.0 and DM server

Paulb — Fri, 12 Dec 2008 16:22:00 GMT

Ok the title is not completely true anymore. I'm back at home, so it's 'almost live' from Devoxx ;-) Yesterday was busy from early morning to early morning, so didn't really find the time to blog... Anyway, the last two Devoxx days where excellent too. I'll split the blogpost in two.

I had a three Spring related sessions. One about the upcoming 3.0 version, and two about the DM server. Probably the most important change in 3.0 is full REST support. Besides that there are countless minor improvements. Minor you might ask, is that all the next version has to offer? Yes it does. Luckily. Spring is really complete already, and I'm glad they choose to just continue the same path without making big changes that aren't really necessary. REST support was something the framework was lacking completely so far however, so I was happy to hear they did a lot of work around this. The MVC framework will support all RESTful properties by (mostly) just setting annotations. Besides some extra annotations for things like different representations, the REST framework feels exactly the same as MVC as we already know. Couldn't be better to my opinion. Besides REST support and a lot of other enhancements they are looking into supporting some JEE6 standards. One of the most interesting things on the list was Webbeans. I don't really see how the Webbeans component model and bijection support could be integrated into Spring without completely turning the Spring component model upside down. Anyway, I exited to see how they plan to get this down.

Besides a new Spring version, I attended two sessions about the DM server. I'm impressed by it. DM server enables you to basically divide your application into OSGI modules and deploy it as such too. This makes it possible to use a shared repository, run multiple versions of an applications and to gracefully update to newer versions. This should also enable to use a more clean programming model, advocating better separation of concerns. I have to try it out myself to see if it really works very convenient however. I'll post some about my findings after trying, and I plan to do some in company presentations about it later on.

Live from Devoxx - Keynote and Parallel programming

Paulb — Wed, 10 Dec 2008 13:35:00 GMT

Keynote and Concurrent programming.

The first keynote was all about JavaFX. Since it's just released last week this was probably the first big presentation of it. Because I've followed JavaFX really really closely for the past months, I didn't hear anything new in the keynote. They did surprise me with one thing however, they had a running JavaFX application on a mobile. Nice :-) Just a few more months before we can try that out too. Anyway, the presentation was done nicely with really good looking demo's. The second part of the keynote was done my IBM about RFID. All conference passes are RFID tagged and they do some tracking with it, and in the keynote they showed how. Interesting, but the talk about the software was really complex with half a million different products stuffed in it. Not really my thing.

Next was about parallel programming. Starting with the pre Java 5 way of doing concurrency, and the new Executor framework in Java 5, Brian gave a good overview of the problems you'll run into with those approaches. The rest of the talk was about the new parallel programming support in Java 7. It was the first time I saw it, and I'm impressed by it. It makes parallel programming much more easy but also much more efficient. Definitively going to try it out at home.

Live from Devoxx - The next version of Flex

Paulb — Tue, 09 Dec 2008 15:49:00 GMT

My morning was all about Flex. The talk was about all the new stuff coming to the Flex platform. I've seen more of Catalyst and it's just simply great.

During the talk a video was shown with a demo of the designer process using Catalyst. With some round tripping between Photoshop, Illustrator and Catalyst they made

a fully working application without actually writing any code. Not that I don't like writing code (of course I do), but the whole interaction design of an application should be done by

a designer, not by me. And that's possible now. Great! Too bad we'll have to wait until late 2009 to start working with it.

The rest of the talk was about Gumbo, the next version of Flex. A lot of interesting new stuff here too. First of all the complete component model is changed in Gumbo.

This makes the creating of custom components a lot easier, and has much better support for separating code and visuals (the skin). The new component model will run parallel with the

existing model, so you're not forced to migrate any existing code.

I've been able to get a very, very early-bits dvd of Catalyst (which I'm installing right this moment) so more about that later :-)

Live from Devoxx - University day 1

Paulb — Mon, 08 Dec 2008 12:50:00 GMT

The Devoxx conference in Antwerp is this week. I'll be posting about sessions this week as much as I can. We just finished the first university session. A university session is normally a 3 hour talk, which makes it possible to go more in depth than normal conference sessions. The session I attended was separated in two talks however.

The first talk was about agile in general. It was a really well presented talk with a lot of real life experience stories. Besides that I didn't really hear a lot of new things. At the end they got more into all kind of practical experiences which was really interesting. Too bad the session didn't span the whole slot, i'm sure it would've been great. One new thing (for me) they explained in detail was the way they do the planning game. First order user stories by difficulty, by moving story cards around at the table, and next do the same but order on business value. By having those two values, it makes it much easier picking stories for a iteration.

The second talk was about Scrum, but presented poorly. I don't know a lot about Scrum, but I didn't really learn a lot from the session either... People have to learn not to write slides as documents and read them line by line. Rather just give me a book, or present in a better way.

I'm now halfway the Servlet 3.0 and JSF 2.0 specs presentation. The Servlet 3.0 spec has some really interesting new additions such as modularization of the web.xml, annotation support and asynchronous support. The Asynchronous support looks really good. It enables you to keep a connection to the client open and push data to it while processing the request. I'm not sure how often you will use the new things in the specs. Most people now uses web frameworks, not servlets directly. But maybe some frameworks can make good use of the new Servlets stuff. We'll see. At least the specs are interesting :-)

Adobe Catalyst - A new step in designer/developer workflow

Paulb — Sat, 06 Dec 2008 14:20:00 GMT

Last week my colleague Alex van Beek visited Adobe Max, and he told me some really impressive things he has seen there. One of the most interesting things that will be available soon is Adobe Catalyst. This is a new tool that helps improving the designer/developer workflow for Flex applications. I checked it out on the website, and it's really impressive.

A designer can simply use tools such as Photoshop and draw a nice looking button. Next the designer can import the layers from this design into Catalyst and just say that the drawing should act as a button, making it also possible to attach specific layers to the various states of the component (mouseover, click, etc.). From than it's a fully working Flex component that can be used within Flex. This is really something I want to have :-)

Haven't we seen this kind of tool before? Yes we certainly have. It's very much like Blend from Microsoft, but better. There are more possibilities, and designers don't have to start using different design tooling. This is something that really puts Flex a step in front of JavaFX again. For JavaFX we have Nile, which can export the layers of a Photoshop or Illustrator design to JavaFX, but there is no possibility to work with different states of a component or create a custom scroll bar easily with Nile.

Check out Catalyst yourself at the following url: http://labs.adobe.com/technologies/flashcatalyst/ There are two movies at the website.