JRoller

Intellij Has Better Support for Scala

evans — Sat, 11 Jul 2009 10:31:44 -0400

The support for Scala in Intellij does a good job of supporting mixed Java / Scala projects. At the moment Scala support in Intellij is better than that of Scala IDE for Eclipse.

As a long time Eclipse user I recently tried installing the Scala IDE on Eclipse 3.3 which already had Flex Builder plug-in installed, but this was not successful, not sure why, but ran into numerous errors. One would expect that mixed Java /Scala support on Eclipse would be seamless, but that's totally not the case.

However, on installing Scala IDE on Intellij, everything worked right without errors or conflicts. I have been able to run different projects on it including Google App Engine and Spring MVC for the UI on Intellij. The plugins for Intellij are a great help. Though it is still early days and there are occasional problems. (for instance the Scala plugin compiler does not seem to like JDO enhanced Java classes too much...there is a work around and I am sure this bug will be fixed soon).

GTK Drawing example done in C

Rick Hightower — Fri, 10 Jul 2009 20:48:40 -0400

I took bits of the example out of the GTK tutorial and started to adapt it. This is just a proof of concept application. I am trying to understand some issues we are having with an application and I wanted to better understand GTK.

I did quite a bit of Swing programming in the past (about 10 years ago). And before that... I did a lot of Windows programming with the C API then later OWL and then later MFC (graphing software for semiconductor test, which was a lot of damn fun).

Eventually this example will do an XY scatter plot. For now, it just draws rectangles based on mouse click and drag events. One must start somewhere. You may notice that it tries to pretend to be a Java class... this was for my own sanity. It is hard to give up on this (pun intentional).

#include <gtk/gtk.h>

typedef struct _components {
    GtkWidget *window;
    GtkWidget *previous;
    GtkWidget *next;
    GtkWidget *graphNavigationPanel;
    GtkWidget *mainPanel;
    GtkWidget *drawingArea;
    GdkPixmap *pixMap;
} components;

static     components this;

static void next_handler( GtkWidget *widget,
                   gpointer   data )
{
    g_print ("next %s \n", (gchar *) data);
}

static void previous_handler( GtkWidget *widget,
                   gpointer   data )
{
    g_print ("previous %s \n", (gchar *) data);
}

static gboolean delete_event( GtkWidget *widget,
                              GdkEvent *event,
                              gpointer   data )
{
    return FALSE;
}

/* Another callback */
static void destroy( GtkWidget *widget,
                     gpointer   data )
{
    gtk_main_quit ();
}

static void createWindow() {
    this.window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    gtk_container_set_border_width (GTK_CONTAINER (this.window), 10);
    gtk_window_set_title (GTK_WINDOW (this.window), "Graph Window");

    g_signal_connect (G_OBJECT (this.window), "delete_event",
              G_CALLBACK (delete_event), NULL);

    g_signal_connect (G_OBJECT (this.window), "destroy",
              G_CALLBACK (destroy), NULL);

}

static void createButtons() {
    this.next = gtk_button_new_with_label ("Next");
    this.previous = gtk_button_new_with_label ("Previous");

    g_signal_connect (G_OBJECT (this.next), "clicked", G_CALLBACK (next_handler), NULL);
    g_signal_connect (G_OBJECT (this.previous), "clicked", G_CALLBACK (previous_handler), NULL);

}

static void layoutWidgets() {
    /* Create the graph navigation panel and add it to the window. */
    this.graphNavigationPanel = gtk_hbox_new (FALSE, 0);
    this.mainPanel = gtk_vbox_new(FALSE, 0);

    gtk_container_add (GTK_CONTAINER (this.window), this.mainPanel);

    /* Add the buttons to the graph navigation panel. */
    gtk_box_pack_start (GTK_BOX(this.graphNavigationPanel), this.previous, TRUE, TRUE, 0);
    gtk_box_pack_start (GTK_BOX(this.graphNavigationPanel), this.next,     TRUE, TRUE, 0);

    /*Add the graph navigation panel to the main panel. */
    gtk_box_pack_start (GTK_BOX(this.mainPanel), this.graphNavigationPanel, TRUE, TRUE, 0);
    /* Add the draw-able area to the main panel. */
    gtk_box_pack_start (GTK_BOX(this.mainPanel), this.drawingArea, TRUE, TRUE, 0);

}

static void show() {
    gtk_widget_show (this.drawingArea);
    gtk_widget_show (this.mainPanel);
    gtk_widget_show (this.next);
    gtk_widget_show (this.previous);
    gtk_widget_show (this.graphNavigationPanel);
    gtk_widget_show (this.window);
}

/* Draw a rectangle on the screen */
static void
draw_brush (GtkWidget *widget, gdouble x, gdouble y)
{
GdkRectangle update_rect;

update_rect.x = x - 5;
update_rect.y = y - 5;
update_rect.width = 10;
update_rect.height = 10;
gdk_draw_rectangle (this.pixMap,
              widget->style->black_gc,
              TRUE,
              update_rect.x, update_rect.y,
              update_rect.width, update_rect.height);
gtk_widget_queue_draw_area (widget,
                              update_rect.x, update_rect.y,
                      update_rect.width, update_rect.height);
}

/* Redraw the screen from the backing pixmap */
static gboolean
expose_event( GtkWidget *widget, GdkEventExpose *event )
{
gdk_draw_drawable(widget->window,
            widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
            this.pixMap,
            event->area.x, event->area.y,
            event->area.x, event->area.y,
            event->area.width, event->area.height);

return FALSE;
}
/* Create a new backing pixmap of the appropriate size */
static gboolean
configure_event( GtkWidget *widget, GdkEventConfigure *event )
{
if (this.pixMap)
    g_object_unref(this.pixMap);

this.pixMap = gdk_pixmap_new(widget->window,
            widget->allocation.width,
            widget->allocation.height,
            -1);

gdk_draw_rectangle (this.pixMap,
              widget->style->white_gc,
              TRUE,
              0, 0,
              widget->allocation.width,
              widget->allocation.height);

return TRUE;
}

static gboolean
button_press_event( GtkWidget *widget, GdkEventButton *event )
{
if (event->button == 1 && this.pixMap != NULL)
      draw_brush (widget, event->x, event->y);

return TRUE;
}

static gboolean
motion_notify_event( GtkWidget *widget, GdkEventMotion *event )
{
int x, y;
GdkModifierType state;

if (event->is_hint)
    gdk_window_get_pointer (event->window, &x, &y, &state);
else
    {
      x = event->x;
      y = event->y;
      state = event->state;
    }

if (state & GDK_BUTTON1_MASK && this.pixMap != NULL)
    draw_brush (widget, x, y);

return TRUE;
}

static void createDrawingArea() {
    this.drawingArea = gtk_drawing_area_new();

    gtk_signal_connect (GTK_OBJECT (this.drawingArea), "expose_event",
                  (GtkSignalFunc) expose_event, NULL);
    gtk_signal_connect (GTK_OBJECT(this.drawingArea),"configure_event",
                  (GtkSignalFunc) configure_event, NULL);
    gtk_signal_connect (GTK_OBJECT (this.drawingArea), "motion_notify_event",
                  (GtkSignalFunc) motion_notify_event, NULL);
    gtk_signal_connect (GTK_OBJECT (this.drawingArea), "button_press_event",
                  (GtkSignalFunc) button_press_event, NULL);

    gtk_widget_set_events (this.drawingArea, GDK_EXPOSURE_MASK
                | GDK_LEAVE_NOTIFY_MASK
                | GDK_BUTTON_PRESS_MASK
                | GDK_POINTER_MOTION_MASK
                | GDK_POINTER_MOTION_HINT_MASK);

    gtk_drawing_area_size(this.drawingArea, 200, 200);
}

int main( int   argc,
          char *argv[] )
{

    gtk_init (&argc, &argv);

    createWindow();
    createButtons();
    createDrawingArea();
    layoutWidgets();
    show();

    gtk_main ();

    return 0;
}

If you want to know the why's and how's of the above code check out: http://library.gnome.org/devel/gtk-tutorial/stable/c2424.html

Seems I am the architect for the next version of this application. Perhaps it will be time to switch to Java Swing, or Java SWT.... (must run on Linux).

Solo Puedo Decir Gracias Selecta

Julian Rivera Pineda — Fri, 10 Jul 2009 20:38:47 -0400

http://ntrock-blog.kuriel.co.cc/wordpress/?p=34

+1

JVM Internals Series -Part 1

Julian Rivera Pineda — Fri, 10 Jul 2009 14:54:46 -0400

http://maneeshchaturvedi.wordpress.com/2009/07/08/jvm-internals-series-part-1/

Injecting timing aspect into JUnit test in Eclipse using AspectJ, AJDT

Jakub Holý (Holy) — Fri, 10 Jul 2009 10:45:51 -0400

Introduction

This blog describes my experience with using AOP, namely AspectJ, to measure the individual execution times and their average of a particular low-level method invoked many times during a JUnit test run from within Eclipse. It concentrates on creating the aspect and integrating (weaving) it into the JUnit test execution.

Of course it would be easier to use e.g. profiler but I wanted to play with AOP/AspectJ to learn it better because it's an incredibly useful tool for a number of problems and you can use it even if you don't have access to the application's source code and/or cannot control the runtime environment (such as running it in a profiler).

Why AspectJ?

There are also other AOP tools for Java but it seems that AspectJ is the most wide-spread one, especially since its merge with AspectWerkz. I used to dislike it because it required a special extended Java syntax and compiler but this isn't true anymnore (more on that later).

Disclaimer

I'm only learning AspectJ, so the solution may be not and likely isn't the best one. I appreciate improvement suggestions.

Preparing the environment

I use Pulse to set up my Eclipse environment. For this I'll use:

Eclipse 3.4 for Java EE (Pulse doesn't yet support 3.5)
AJDT 2.0.0
AspectJ 1.6.5
JUnit 4
JDK 1.5.0.18 (the test fails with 1.6 due to xml libs incompatibility) and Java 5.0 syntax

Implementing the timing aspect

My goal is to create an aspect invoked around the method in question that will measure the time it takes for the method to execute, log it, and compute and log the average execution time.

Since AspectJ 5 we have two options - either using the older custom AspectJ syntax with AspectJ compiler or using annotations. I'll explore both possibilities.

Project structure

First, we have a Java project with the junit test that we want to run with the timing aspect. It depends on another project with the actual class and method whose performance we want to measure.

MyLibraryProject

/src/main/java/com/tonbeller/jpivot/xmla/XMLA_SOAP.java

MyTestProject

/src/main/java/

eu/ibacz/studna/jpivot/OLAPModelStructure.java
- calls (indirectly) XMLA_SOAP.discoverMem during its execution

/src/test/java/

eu/ibacz/studna/jpivot/OLAPModelStructurePerformanceTest.java
- standard JUnit4 test case

We create another project to hold our new shiny aspect: File > New > Other... > AspectJ > AspectJ Project =>

MyAspectProject

/src/

eu/ibacz/pbns/util/aspect/TimingAspect.aj (solution 1)
eu/ibacz/pbns/util/aspect/TimingAnnotatedAspect.java (solution 2)

Solution 1: using custom ApectJ syntax

Before AspectJ 5 this was the only option and it is still more powerful and has better support of AJDT (according to the FAQ). Basically you write the aspect in an extended Java syntax in an .aj file and compile it with a special AspectJ compiler - though this is done behind the scene for you thanks to having created an AspectJ project, which also provides you with a special AspectJ/Java editor for .aj and .java aspect files.

Enough talking, let's see the aspect:

File eu/ibacz/pbns/util/aspect/TimingAspect.aj:

package eu.ibacz.pbns.util.aspect;

import ...

public aspect TimingAspect {

    // instance/class field ...

    public TimingAspect() {
        formatter = NumberFormat.getIntegerInstance();
        formatter.setMinimumIntegerDigits(3);
        System.out.println(getClass() + " instantiated!");
    }


//  before(): execution(public * com.tonbeller.jpivot..XMLA_SOAP.*(..) ) {
//      System.err.println("About to call " + thisJoinPoint.getSignature().toShortString() + ", args:" + Arrays.toString(thisJoinPoint.getArgs()) );
//  }

    Object around() : execution( * com.tonbeller.jpivot..XMLA_SOAP.discoverMem(..) ) {

        final long startTimeCpuMs = getCurrentTimeMs();
        final long startTimeMs = System.currentTimeMillis();

        Object result = proceed();


        final long endTimeMs = System.currentTimeMillis();
        final long endTimeCpuMs = getCurrentTimeMs();

        final long execTimeMs = endTimeMs - startTimeMs;
        final long execTimeCpuMs = endTimeCpuMs - startTimeCpuMs;

        ++totalExecutionCount;
        totalExecutionTimeMs += execTimeMs;
        totalCpuExecutionTimeMs += execTimeCpuMs;

        final String msg = "executing discoverMem #" + formatter.format(totalExecutionCount) +
                " took " + execTimeCpuMs + "ms of CPU, " +
                execTimeMs + "ms real; current average is [ms/call]: " +
                totalCpuExecutionTimeMs / totalExecutionCount + " for CPU, " +
                totalExecutionTimeMs / totalExecutionCount + " real time.";
        System.out.println(getClass().getName() + ": " + msg);

        return result;
    }

}

(I've ommited the fields and some methods for brevity.)

PS: You can use the commented-out before adivce to print all methods called on XMLA_SOAP including their name and arguments. This is useful to find out whether the method you're trying to measure is actually called at all.

Solution 2: using annotation (@AspectJ)

Since AspectJ 5 we can use a normal Java class with special annotations to define an aspect. It's less powerful (see above) but more familiar to a Java developer and more comfortable to use since it doesn't need any special compiler (the annotations are processed by AspectJ during weaving).

File eu/ibacz/pbns/util/aspect/TimingAnnotatedAspect.java:

package eu.ibacz.pbns.util.aspect;

import ...

@ Aspect
public class TimingAnnotatedAspect {

    // instance/class fields ...    

    public TimingAnnotatedAspect() {
        formatter = NumberFormat.getIntegerInstance();
        formatter.setMinimumIntegerDigits(3);
        System.out.println(getClass() + " instantiated!");
    }

    @Around("execution( * com.tonbeller.jpivot..XMLA_SOAP.discoverMem(..) )")
    public Object measureTime(ProceedingJoinPoint pjp) throws Throwable {

        final long startTimeCpuMs = getCurrentTimeMs();
        final long startTimeMs = System.currentTimeMillis();

        Object result = pjp.proceed();


        final long endTimeMs = System.currentTimeMillis();
        final long endTimeCpuMs = getCurrentTimeMs();

        final long execTimeMs = endTimeMs - startTimeMs;
        final long execTimeCpuMs = endTimeCpuMs - startTimeCpuMs;

        ++totalExecutionCount;
        totalExecutionTimeMs += execTimeMs;
        totalCpuExecutionTimeMs += execTimeCpuMs;

        final String msg = "executing discoverMem #" + formatter.format(totalExecutionCount) +
                " took " + execTimeCpuMs + "ms of CPU, " +
                execTimeMs + "ms real; current average is [ms/call]: " +
                totalCpuExecutionTimeMs / totalExecutionCount + " for CPU, " +
                totalExecutionTimeMs / totalExecutionCount + " real time.";
        System.out.println(getClass().getName() + ": " + msg);

        return result;
    }
}

As you can see, we've replaced the special AspectJ syntactical elements with annotationes @Aspect and @Around (there is also @Pointcut and others).

(I've ommited the fields and some methods for brevity.)

Common project info

For both project we need to have the class to modify with the aspect, in our case XMLA_SOAP, on the classpath, to get some special support from AJDT (see below).

The good thing when using AJDT is that if a pointcut definition (such as the execution(...) above) doesn't match an existing class/method, you will be warned about it - in Eclipse there will be the standard warning marker with text like "no match for this type name: XMLA_SOAP [Xlint:invalidAbsoluteTypeName]". This works both for .aj and .java files though it may not discover all issues.

The common code, if you're interested:

    private ThreadMXBean threadMxb;

    /**
     * Return the current time in miliseconds, if possible, return only the current thread's CPU time, if not,
     * return system time.
     * <p>
     * thread's CPU time is usually few times less than the absolute time between
     * its start and end due to the fact that it has to share the CPU with other processes/threads.
     */
    private long getCurrentTimeMs() {
        return getThreadMxBean().isCurrentThreadCpuTimeSupported()?
                threadMxb.getCurrentThreadCpuTime() / 1000000 : System.currentTimeMillis();

    } /* getCurrentTimeNano */

    /** Lazy-init getter. */
    private ThreadMXBean getThreadMxBean() {
        if (threadMxb == null) {
            threadMxb = ManagementFactory.getThreadMXBean();

            if (threadMxb.isThreadCpuTimeSupported()) {
                LOG.info("Thread user/cpu time monitoring supported.");
                if (threadMxb.isThreadCpuTimeSupported() && threadMxb.isThreadCpuTimeEnabled()) {
                        LOG.info("Thread user/cpu time monitoring supported&enabled."); // TODO do only once
                } else {
                    LOG.warn("Thread user/cpu time monitoring supported but disabled.");
                }
            } else {
                LOG.warn("Thread user/cpu time monitoring NOT supported.");
            } // supported thr. time
        }

        return threadMxb;
    } /* getThreadMxBean */

Integrating the aspect into the JUnit test

Our tracing aspect is ready and we want to apply it to XMLA_SOAP.discoverMem when running our JUnit test OLAPModelStructurePerformanceTest. Unfortunately AJDT doesn't provide any support for running JUnit tests with AspectJ support though it does that for normal java programs via the additional Run As... > AspectJ/Java Application menu item therefore we will need to do it manually. Maybe there is a better way but this is what I did:

Get aspectjweaver.jar - it includes complete AspectJ runtime plus Java 5 agent lib.
Modify the Run configuration of the JUnit test (Run > Run Configurations) as follows:

On the tab Arguments, add the VM argument
-javaagent:/path/to/aspectjweaver.jar
On the tab Classpath, click on User Entries and add there the project MyAspectProject so that it can see the aspect.

In the project MyTestProject create under /src/test/java/ (or any other source folder) META-INF/aop.xml with the content shown below.

File aop.xml :

<aspectj>
    <aspects>
        <!-- aspect name="eu.ibacz.pbns.util.aspect.TimingAspect"/--> <!--  fails if not found -->
        <aspect name="eu.ibacz.pbns.util.aspect.TimingAnnotatedAspect"/>
    </aspects>
</aspectj>

This file tells AspectJ's Load-Time Weaver what aspects to introduce into the existing classes. Without it no instrumentation would occur. You can configure here which of the 2 aspects to use.

Troubleshooting load-time weaving

If you need to learn more about what AspectJ does during the weaving and whether it does modify the target class or not (e.g. due to wrong pointcut match pattern or classpath order) you may enable some logging using either some properties on the command-line or by specifying this in the aop.xml:

<aspectj>
    <aspects>
        <!-- aspect name="eu.ibacz.pbns.util.aspect.TimingAspect"/--> <!--  fails if not found -->
        <aspect name="eu.ibacz.pbns.util.aspect.TimingAnnotatedAspect"/>
    </aspects>
    <weaver options="-verbose -showWeaveInfo "> <!-- -debug  -->
        <include within="com.tonbeller.jpivot.xmla.*"/>
        <include within="eu.ibacz.*"/>
    </weaver>
</aspectj>

If the weaving proceeds as expected, this should produce an output similar to the one below:

[AppClassLoader@1858610] info AspectJ Weaver Version DEVELOPMENT built on Friday Aug 29, 2008 at 00:25:33 GMT
[AppClassLoader@1858610] info register classloader sun.misc.Launcher$AppClassLoader@1858610
[AppClassLoader@1858610] info using configuration /home/jholy/devel/MyTestProject/target/classes/META-INF/aop.xml
[AppClassLoader@1858610] info register aspect eu.ibacz.pbns.util.aspect.TimingAspect
[AppClassLoader@1858610] info processing reweavable type com.tonbeller.jpivot.xmla.XMLA_Model: com/tonbeller/jpivot/xmla/XMLA_Model.java
[AppClassLoader@1858610] info successfully verified type eu.ibacz.pbns.util.aspect.TimingAspect exists.  Originates from eu/ibacz/pbns/util/aspect//home/jholy/devel/MyAspectProject/src/eu/ibacz/pbns/util/aspect/TimingAspect.aj
[AppClassLoader@1858610] weaveinfo Join point 'method-execution(void com.tonbeller.jpivot.xmla.XMLA_Model.retrieveMemberChildren(com.tonbeller.jpivot.xmla.XMLA_Member))' in Type 'com.tonbeller.jpivot.xmla.XMLA_Model' (XMLA_Model.java:1094) advised by around advice from 'eu.ibacz.pbns.util.aspect.TimingAspect' (TimingAspect.aj:56)

The line 'info register aspect eu.ibacz.pbns.util.aspect.TimingAspect' tells us that AspectJ has found the aspect referenced from aop.xml. If the aspect class didn't exist that it would print an error message.

The line 'weaveinfo Join point ...' tells us that AspectJ has actually found and modified the target.

If you enabled -debug in aop.xml, AspectJ would print the list of classes that it has processed (whether there was an aspect to apply or not) - this can help you to verify that it doesn't ignore your target class.

Conclusion

It works! :-)

Resources

AspectJ Quick Reference - pdf, 4 pages.
AspectJ: Semantics of pointcuts - we need the Type patterns described close to the very end

How to create a custom FacesContext

Kenan Sevindik — Fri, 10 Jul 2009 07:32:36 -0400

Why Wolfram Alpha Really Fails

Sebastian Kübeck — Fri, 10 Jul 2009 06:36:24 -0400

In a recent post, Mencius Moldbug criticises Wolfram Alpha and claims that natural language interfaces don't work for application control but do work for search engines.

They create an incomplete model of the giant electronic brain in their own, non-giant, non-electronic brains. Of course, since the giant electronic brain is a million lines of code which is constantly changing, this is a painful, inadequate and error-prone task.

It doesn't come as a surprise that Joel Spolsky, the man that declared the usability problem is solved, agrees with him. Great minds think alike, don't they?
Let's have a look at the example he provides as proof of his hypothesis:

The site was also bedeviled by an inflexible natural-language interface. For example, if you searched for "Isaac Newton birth," you got Newton's birth date (December 25, 1642; you also learned that the moon was in the waxing-crescent phase that day). But if you searched for "Isaac Newton born," Alpha choked. Aaronson tested it with me and found it couldn't answer "Who invented the Web?" and didn't know state-level GDP figures, only national ones.

Trying "Isaac Newton born" got me the following result:

Wolfram|Alpha isn't sure what to do with your input.

What is the Problem?

So what is the problem here? The user's inability to formulate the request properly? The fact that Wolfram Alpha can't deal with the request or the response?
Anyone with just the slightest experience in user interface design (that is, no former Microsoft or Sun employee) will know the answer:

The response is not helpful! It doesn't even contain any useful information!

The natural language interface as such is not the problem nor is the lack of Alpha's knowledge the problem. It's just the response.

Possible Solutions

How could this problem be solved? Well, Alpha got at least some useful information: "Isaac Newton", it just doesn't know the last word so why doesn't Alpha show what it knows about Isaac Newton? This could look like the following:

Unfortunately, I could not process your input so please help me out.
Does the following summary contain the functionality or information you are looking for?

Isaac Newton
From Wikipedia, the free encyclopedia

Sir Isaac Newton, FRS (4 January 1643 – 31 March 1727 [OS: 25 December 1642 – 20 March 1727])[1], was an English physicist, mathematician, astronomer, natural philosopher, alchemist, and theologian. His Philosophiæ Naturalis Principia Mathematica, ...

[read more]

If you found the response you were looking for, please let me know: __________________

[Submit]

---

Thank you four your contribution!

The last line would make sure that Alpha knows the answer next time.

Conclusion

Note that most people out there are helpful. They don't require that applications are perfect or even omniscient, they just don't want to be treated like idiots.

For more information, see Alan Cooper's books on interaction design.

Compte rendu de la soirée RIA au ParisJUG

Le Droff — Fri, 10 Jul 2009 05:29:51 -0400

Voici mon compte rendu de la Soirée RIA au ParisJUG

J'y ai donc tenté(*) de présenter :

rapidement l'offre RIA Adobe (pour les nombreux juggers qui ne la connaissaient pas)
puis la mise en place des services Flex (remoting, messaging et data-management) avec Spring-Flex
et enfin un rapide aperçu de FlashCatalyst

(*) l'exercice était assez difficile, j'ai du faire avec quelques petits problèmes techniques: micro, ampli et écran (pour l'écran, c'était de ma faute, j'aurai mieux fait de cloner mon écran sur le projo, c'eût été bien plus simple pour les démo...) m'enfin… , voici les slides :

Flex Services And Spring with Spring-Flex ParisJug

View more documents from francoisledroff.

Contrairement à ce qu'indique Le Touilleur dans son blog, les articles de Franck et Sébastien ne présentent pas cette technologie mais l'ancienne approche, la première intégration du Flex Remoting offerte par Jeff Vroom à travers sa SpringFactory. Ce qu'il faut retenir c'est que Spring-Flex (ce nouveau socle technique issu d'un partenariat Adobe Spring-Source) va beaucoup plus loin et facilite énormément la mise en place d'un front-end Flex au dessus d'un back-end (Spring) java. Il permet par exemple:

de mettre d'exposer un service Flex Remoting avec une simple annotation org.springframework.flex.remoting.RemotingDestination
de sécuriser les canaux de communication de façon quasi transparent avec Spring-Security

Pour plus de détails, voir:

mes slides
Le "test drive" de Christophe Coenraets
Spring By Example
La doc complète de Spring-Flex
ou encore le code source (mavenisé) de ma démo http://fna-v2.googlecode.com/svn/trunk/samples/riveria_jug/spring_flex_todo/ donnée également au RiveriaJUG

J'ai terminé ma session par une démo trop rapide de ce que l'on peut faire avec FlashCatalyst, (j'aurai du faire abstraction de 75% des juggers utilisateurs de spring présents dans la salle et commencer par ça. La session aurait été bien plus fun et moins rébarbative, Le sujet spring-flex était en effet plus adapté pour un lab ou une formation...)

Voici donc en bonus quelques slides présentant FlashCatalyst :

Flash Catalyst Jug

View more documents from francoisledroff.

Pour la démo, je pars donc d'un design réalisé sous Illustrator, je passe par Catalyst pour en faire une DataList Flex4, et hop sous Eclipse/FlashBuider, j'incorpore le composant DataList skinné:

On notera que pour ce petit composant, le code source généré par FlashCatalyst reste propre et ne pollue en rien mon projet de départ, pour preuve, je vous ai mis à disposition le code source de la démo sur google-code : http://fna-v2.googlecode.com/svn/trunk/samples/riveria_jug/simple_fc_skinned_i18n_todo_client/.

Si vous voulez essayer cette techno, allez donc faire un tour sur le blog de Thibault, il y a publié le résultat de son « évangelisation » catalyst : http://www.bytearray.org/?p=839. Vous y trouverez tout pour skinner une appli de type « adobe directory » avec Flex4 et FlashCatalyst (et en français!).

Après la pause, c'était Simon Ritters qui présentait JavaFX, Michael nous en a fait un compte rendu. Ceux qui ont aimé la démo wiimote de JavaFx vont forcement adoré les démos de Thibault et de son wiiFlash. (Et dire que Simon et Thibault sont payés pour faire ça !! nous sommes forcement tous jaloux !! )

World-Shortest MapReduce Application

Nikita Ivanov — Fri, 10 Jul 2009 03:58:18 -0400

Developer's productivity is one of the key concerns for us in GridGain project and I just found a little piece of code that demonstrates this so well... As part of 3.0 mega-release we are all working on right now we will be shipping two new annotations for automatic grid-enabling:

@GridifySetToSet
@GridifySetToValue

I already blogged about details on these but here's the perfect example of probably the world-shortest full fledged MapReduce application (finding max element in the collection on the grid):

@GridifySetToValue(threshold=200)
public <T extends Comparable<? super T>> T findMaxOnCloud(Collection<T> input) {
    return Collections.max(input);
}

That's all. This method will find maximum value in the input collection by splitting the input collection into multiple sub-collection (unless input collection has fewer than 200 elements, as in our example), shipping those collections to remote nodes on the grid (local cluster, cloud, EC2, etc.), find max value in those sub-collection and then find max value among max values from the sub-collection to finally get the actual max value of the input collection. 4 lines of code all in all give you load balancing, automatic failover, peer-to-peer class loading, collision and topology resolution, auto-discovery and plenty other core GridGain features out-of-the-box - while you just write those 4 lines of code...

As always with GridGain this mini-application will work exactly the same way on 1 node, 2 nodes or 1024 nodes - either on your laptop or on the largest Java-based EC2 cloud. And any idempotent methods with set-to-set or set-to-value reduction semantics will be able to get grid-enabled in the same way - just one annotation.

Exciting!

Left Handed Laptop

Reza Ghaffaripour — Fri, 10 Jul 2009 00:58:25 -0400

I am looking for a left handed laptop! It might seem odd but I am serious.

I have a Lenovo SL300. The problem with that is the heat exhaust is on the left and sometimes I can't use my own wired mouse as it will burn my hand!

Other problem I remember from my old DELL (and my current one too) was that the Wireless board (or hard drive?) was under the left palm rest area and it used to get really hot!

I wonder if manufacturers really care or not. The least thing I expect is to exactly indicate which ports (USB, power slot, etc.) are located where on the laptop. Also where is the location of component that might get warm such as HDD, wireless, CPU, etc. This shouldn't be among those things they would change without notice!

FileUpload with GWT

Hasan Turksoy — Thu, 9 Jul 2009 18:03:10 -0400

I need a file upload solution in my Google Web Toolkit (GWT) project. While googling, I have found many related posts asking about the subject. Also, there are some projects arround providing this functionality. But, I couldn't find any tutorial explaining the file upload solution from start to end or building a sample application to demonstrate the ability on GWT. So that, I have decided to write my experiences here to help to the developers in need.

If you don't want to use/depend any other (may be not mature and extendible enough) third party library just to make a simple file upload operation, and want to develope your clean and extendible solution, then, go on and follow the steps below :)

GWT provides an RPC (Remote Procedure Call) infrastructure to make Ajax calls easily but RPC mechanism implies reading the file which violates the whole browser flow being achieved through javascript. Browser should be responsible from reading and submitting the file. Therefore, we can not use RPC for file upload operations. We have to submit the file somehow.

There are alternative solutions for file upload like flash based approaches as here, or by the help of Google Gears (which will necessitate your users installing Gears), or using pure JavaScript as here... But it is apperant that the most common way is using plain Servlet technology. I will demonstrate this solution in this post.

File Upload using Servlet

Client Side:

In the client side, GWT provides a FileUpload widget which must be used in a FormPanel to make a submit to the server. Make sure, you need to give a name (via setName(String)) to all of the fields under the FormPanel so that the HttpServlet can identify them. Below is the slightly modified GWT client code from FileUpload javadoc, which includes the FileUpload widget together with several normal fields.


GWT File Upload Client Code


01 /**

02  * GWT entry point class.

03  * 

04  * @author hturksoy

05  */

06 public class GWTFileUpload implements EntryPoint {

07     private static final String UPLOAD_ACTION_URL = GWT.getModuleBaseURL() + "upload";

08 

09     /**

10      * This is the entry point method.

11      */

12     public void onModuleLoad() {

13         // Create a FormPanel and point it at a service.

14         final FormPanel form = new FormPanel();

15         form.setAction(UPLOAD_ACTION_URL);

16 

17         // Because we're going to add a FileUpload widget, we'll need to set the

18         // form to use the POST method, and multipart MIME encoding.

19         form.setEncoding(FormPanel.ENCODING_MULTIPART);

20         form.setMethod(FormPanel.METHOD_POST);

21 

22         // Create a panel to hold all of the form widgets.

23         VerticalPanel panel = new VerticalPanel();

24         form.setWidget(panel);

25 

26         // Create a TextBox, giving it a name so that it will be submitted.

27         final TextBox tb = new TextBox();

28         tb.setName("textBoxFormElement");

29         panel.add(tb);

30 

31         // Create a ListBox, giving it a name and some values to be associated

32         // with its options.

33         ListBox lb = new ListBox();

34         lb.setName("listBoxFormElement");

35         lb.addItem("foo", "fooValue");

36         lb.addItem("bar", "barValue");

37         lb.addItem("baz", "bazValue");

38         panel.add(lb);

39 

40         // Create a FileUpload widget.

41         FileUpload upload = new FileUpload();

42         upload.setName("uploadFormElement");

43         panel.add(upload);

44 

45         // Add a 'submit' button.

46         panel.add(new Button("Submit", new ClickHandler() {

47             public void onClick(ClickEvent event) {

48                 form.submit();

49             }

50         }));

51 

52         // Add an event handler to the form.

53         form.addSubmitHandler(new FormPanel.SubmitHandler() {

54             public void onSubmit(SubmitEvent event) {

55                 // This event is fired just before the form is submitted. We can

56                 // take this opportunity to perform validation.

57                 if (tb.getText().length() == 0) {

58                     Window.alert("The text box must not be empty");

59                     event.cancel();

60                 }

61             }

62         });

63 

64         form.addSubmitCompleteHandler(new FormPanel.SubmitCompleteHandler() {

65             public void onSubmitComplete(SubmitCompleteEvent event) {

66                 // When the form submission is successfully completed, this

67                 // event is fired. Assuming the service returned a response of type

68                 // text/html, we can get the result text here (see the FormPanel

69                 // documentation for further explanation).

70                 Window.alert(event.getResults());

71             }

72         });

73 

74         RootPanel.get().add(form);

75 

76     }

77 

78 }

There are a few points to remember;

@line 14-20: set the form to use POST method and mutipart MIME encoding
@line 48: you have to submit the form to send data to the server
@line 53: you can set a SubmitHandler for your FormPanel widget to make necessary operations just before the form is submitted
@line 64: you can set a SubmitCompleteHandler to handle returning result(response) to your submit request

Server Side:

At server side, our Servlet will handle only multipart requests and process only fileupload request item(s). After writing the file to a system directory, sends a success response. Alternatively, you can put incoming file content into server session, or use it for other server side purposes. Our Servlet code is as below;


File Upload Servlet


01 /**

02  * servlet to handle file upload requests

03  * 

04  * @author hturksoy

05  * 

06  */

07 public class FileUploadServlet extends HttpServlet {

08 

09     private static final String UPLOAD_DIRECTORY = "d:\\uploaded\\";

10 

11     @Override

12     protected void doGet(HttpServletRequest req, HttpServletResponse resp)

13             throws ServletException, IOException {

14         super.doGet(req, resp);

15     }

16 

17     @Override

18     protected void doPost(HttpServletRequest req, HttpServletResponse resp)

19             throws ServletException, IOException {

20         

21         // process only multipart requests

22         if (ServletFileUpload.isMultipartContent(req)) {

23 

24             // Create a factory for disk-based file items

25             FileItemFactory factory = new DiskFileItemFactory();

26 

27             // Create a new file upload handler

28             ServletFileUpload upload = new ServletFileUpload(factory);

29 

30             // Parse the request

31             try {

32                 List<FileItem> items = upload.parseRequest(req);

33                 for (FileItem item : items) {

34                     // process only file upload - discard other form item types

35                     if (item.isFormField()) continue;

36                     

37                     String fileName = item.getName();

38                     // get only the file name not whole path

39                     if (fileName != null) {

40                         fileName = FilenameUtils. getName(fileName);

41                     }

42 

43                     File uploadedFile = new File(UPLOAD_DIRECTORY, fileName);

44                     if (uploadedFile.createNewFile()) {

45                         item.write(uploadedFile);

46                         resp.setStatus(HttpServletResponse.SC_CREATED);

47                         resp.getWriter().print("The file was created successfully.");

48                         resp.flushBuffer();

49                     } else

50                         throw new IOException("The file already exists in repository.");

51                 }

52             } catch (Exception e) {

53                 resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,

54                         "An error occurred while creating the file : " + e.getMessage());

55             }

56 

57         } else {

58             resp.sendError(HttpServletResponse.SC_UNSUPPORTED_MEDIA_TYPE,

59                             "Request contents type is not supported by the servlet.");

60         }

61     }

62 }

A few things to remember;

@line 9: this upload directory must exist (of course you can create it on the fly using java.io.File#mkdirs method)
@line 50: throws an error if the uploaded file already exists in the repository. You can use alternative algorithms here like appending unique numbers to the name of the duplicate files. I just skip these for simplicity

Configuration:

That's all about development. Below are the extra activities to make the project run.

get the commons-fileupload and commons-io jars, and put them in your lib dir (war/WEB-INF/lib) and classpath. Current versions are commons-fileupload-v1.2.1, commons-io-v1.4

configure your file upload servlet mapping in web.xml like below;

`web.xml`
`<!-- Servlets --> <servlet> <servlet-name>uploadServlet</servlet-name> <servlet-class>com.hsn.demo.gwtfileupload.server.FileUploadServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>uploadServlet</servlet-name> <url-pattern>/gwtfileupload/upload</url-pattern> </servlet-mapping>`

That's all!... You can build your own file upload on GWT by following above steps, or, you can get the working project from here ;).

Web Communications enhancing interactions

Erik Burckart — Thu, 9 Jul 2009 16:03:22 -0400

One of the common questions as people are learning about our WebSphere Communications Enabled Applications (CEA) function is if we are trying to replace interactions with "real people" when they see features such as the cobrowsing. The real idea behind CEA is using an interactions via the web to enhance real time communications which could be phone calls or instant messaging. There are several scenarios that we try to show in the demo video below, but here are some of the common issues that a web based interaction could solve in a contact center:

- More -

JSFCAL - month-view JSF Component

Mert Caliskan — Thu, 9 Jul 2009 12:05:35 -0400

http://code.google.com/p/jsfcal

This project contains a month-view calendar, which is based on the fullcalendar, with drag&drop abilities on the events. It also supports exporting events of a month to iCal. All actions are implemented via PL. Here is how it looks.

How to use it with Maven?

just add repo definition to your pom.xml




public class Test {



  <repository>

     <id>jsfcal-repo</id>

     <name>JSFCal Repository</name>

     <url>http://jsfcal.googlecode.com/svn/trunk/mavenrepo/</url>

  </repository>

and then add the dependency. Then you're good to go.


  <dependency>

     <groupId>tr.richfacesext</groupId>

     <artifactId>jsfcal-core</artifactId>

     <version>0.1</version>

  </dependency>

}

You can also download artifacts for v0.1 (jar, war) here.

What do I need on the coding side?

You have to supply a Collection as a value to the component. The tr.richfacesext.components.jsfcal. Event interface contract is given below. You can find a concrete impl. of Event here.


package tr.richfacesext.components.jsfcal;



import java.io.Serializable;

import java.util.Date;




/**

 * 

 * @author mert

 *

 */

public interface Event extends Serializable {




  Long getEventId();

  

  String getTitle();

  

  String getDescription();


  

  Date getStartDate();

  

  Date getEndDate();

  

  boolean isReadOnly();

}

With facelets, add namespace declaration like,

xmlns:jsfcal="http://code.google.com/p/jsfcal"

and use the month-view component like,

<jsfcal:month id="monthView" value="#{monthViewController.events}" />

What attributes does the component have?

initYear : The year that will be displayed when the calendar first loads. By default it's the current year.
initMonth : The month that will be displayed when the calendar first loads. By default it's the current month.
readOnly : When set to true, events couldn't be dragged. By default it's false.
width : Width of the calendar. By default it's 650px.
height : Height of the calendar. By default it's 550px.
abbrevDayHeadings : Whether to display 'Sun' versus 'Sunday' for days of the week. By default it's true.
title : Determines whether a title such as 'January 2009' will be displayed at the top of the calendar. By default it's true.
language : See Localization section for detailed info.

Localization

Component has a property named language to set the locale in a declarative way (values are given in supported locales part).
If that property is not set, it uses context.getViewRoot().getLocale().getLanguage() to identify the locale.
If you've provided locale settings in your faces-config properly, the FacesServlet will take care of setting it while creating the view.
And JSFCal will use it. Start day of the week is being set according to the locale also.

Supported locales are: tr, de, en, es, fr, it, ro, ru.

Writing EDT-safe Swing UI tests

Alex Ruiz — Thu, 9 Jul 2009 11:33:01 -0400

Lately, I noticed that one of the main topics in the FEST mailing list is violation of Swing's threading policy in UI tests. Surprisingly, this subject is not really referenced directly. Most of the time, it appears in the form of questions, code snippets or test cases not related to Swing threading at all. It seems like we are still not fully aware of the event dispatch thread (EDT,) even though it has been around for many years (10+ maybe?)

Rest of blog post can be found here.

XINS 2.3-alpha1 released with Google App Engine support

Anthony Goubard — Thu, 9 Jul 2009 07:32:29 -0400

Yesterday I've released XINS 2.3-alpha1.
The main feature of this release is the possibility to deploy the web services created with XINS in Google App Engine for Java.
The changes include modification in the XINS engine to handle the ClassNotFoundError thrown by GAE and a new appengine target to help you deploy the web service in GAE.

See a demo at http://xins.sourceforge.net/demo/specdocs/myproject/index.html

Developing a Python Application Using NetBeans IDE

Julian Rivera Pineda — Thu, 9 Jul 2009 04:36:07 -0400

http://www.netbeans.org/kb/docs/python/python-quickstart.html

Working with Qt Applications - NetBeans IDE 6.7 Tutorial

Julian Rivera Pineda — Thu, 9 Jul 2009 04:33:50 -0400

http://www.netbeans.org/kb/docs/cnd/qt-applications.html

spring-json view 1.2 added to maven 2 repository

Kai Ulrich — Thu, 9 Jul 2009 04:08:47 -0400

http://spring-json.sourceforge.net/

Spring Json-View adds JavaScript Object Notation (JSON) support to
Spring-MVC. Now spring-json 1.2 is added to the maven 2 central repository :

http://repo1.maven.org/maven2

usage:

<dependency>

    <groupId>net.sf.spring-json</groupId>

    <artifactId>spring-json</artifactId>

    <version>1.2</version>

</dependency>

localhost sweet localhost

Julian Rivera Pineda — Wed, 8 Jul 2009 19:29:06 -0400

cross-browser-window-communication

Matthias Wessendorf — Wed, 8 Jul 2009 15:40:34 -0400

Helps to avoid some shortcuts for current comet solutions...

Some Thoughts on Google Chrome OS

Sebastian Kübeck — Wed, 8 Jul 2009 05:59:09 -0400

Google recently announced that they are building a new operating system. They are primarily targeting the netbook marked but Chrome OS will run on notebooks and PCs too. [Added: Kent Beck's reaction]

Speed, simplicity and security are the key aspects of Google Chrome OS. We‘re designing the OS to be fast and lightweight, to start up and get you onto the web in a few seconds. The user interface is minimal to stay out of your way, and most of the user experience takes place on the web. And as we did for the Google Chrome browser, we are going back to the basics and completely redesigning the underlying security architecture of the OS so that users don‘t have to deal with viruses, malware and security updates. It should just work.

Although it‘s true that Chrome OS will not be able to compete with the huge number of applications for other operating systems any time soon, Google is hitting several pain points of existing operation systems:

Less Skilled Users

Over time, computers got more and more popular but the technical skills of people using computers are constantly declining at average. Nowadays operating systems however have their roots in the seventies and before. They were made for users with pretty high technical skills. The vast majority of nowadays users neither have those skills nor are they able to acquirer them (just think about elder people without technical background). On the other hand, there is a lot of of social pressure for those people to use the web.

Decreasing Importance of Desktop Applications

Operating system vendors are pointing at the huge number of applications that are available for their products but that asset gets less important given the following facts:

More and more applications are replaced by web based ones

The aforementioned new users hardly ever use applications beyond the web browser

There is a lot of tinkering involved to keep current operating systems running. As a result, less skilled users have to beg more skilled friends and relatives to help them with their computer problems. However, nobody likes to be dependent on others so those users will sacrifice a great deal of functionality to reduce that dependency.

More Influence for Hardware Vendors

Computer hardware vendors are rather tied to Microsoft‘s operating systems (except from Apple of course) and it seems that they aren‘t too happy with that constraint. So it did not come as a surprise that IBM, HP and others have been more or less openly supporting Linux to reduce the dependency on Microsoft products. That way, they are about to gain more influence on Microsoft‘s product strategies.

Conclusion

After years of stagnation on the desktop (note that those desktops got more and more features, they got prettier along the way but the basic mechanisms haven‘t changed in almost thirty years), we will see things moving again. Exciting, isn‘t it?

Added 0709/2009: Kent Beck: Chrome OS is Worse, That’s the Point

The next step in the innovator’s dilemma script is predictable. The existing participants will ignore Chrome (they may fuss, but they aren’t going to introduce something even simpler, even better, even cheaper–that’s just not how they think). Chrome OS will grow better and better, and be attractive on bigger and bigger hardware. More and more of the necessary apps will migrate to the browser or be replaced by inferior-but-good-enough entrants (do you hear that, Skype?) Since Chrome OS is genuinely better along some dimensions, the motivation is there for users, for application developers, and for Google to continue the march.

After a decade of nibble, nibble, nibble, Apple and Microsoft will occupy highly-profitable but miniscule markets. If I had to guess I would say that Apple will have the very best high end desktops and Microsoft will be strong on servers. By that time, though, Chrome OS will have grown bloated with seemingly-indispensible features and will be ripe for a little nibble, nibble, nibble of its own.
[...]
The current desktops are dead, even though they will linger for a decade or more. Welcome, Chrome OS. Here’s to a worse future.

Better Looking Charts

David Gilbert — Wed, 8 Jul 2009 04:36:46 -0400

A simple technique to make a chart more attractive is to use a suitable background image. This has been supported in JFreeChart for a long time, but I haven't done a lot to promote the feature. Recently a friend (not a JFreeChart user) asked me for some advice on jazzing up some charts for a presentation he was giving to senior executives at the bank he works for. I played about with some images from iStockPhoto.com and came up with a couple of examples. The first is a sales chart:

The second is a quadrant chart (these are quite popular in management circles):

The source code for the latter chart is here, and both examples will be added to the demo collection that ships with the JFreeChart Developer Guide (that thing that provides most of the funding for JFreeChart).

I'm also running short of paid work right now, so if you have a Java project that could benefit from integrating charts like these, please take a look at my profile and give me a call.

Visual JPA with Ajax Push

Ted Goddard — Tue, 7 Jul 2009 16:21:46 -0400

Bilal Ahamed has put together a tutorial on Using Java Persistence API in a Visual Web ICEfaces framework and NetBeans including Ajax Push.

An interesting variation would be to try the SessionRenderer in this application (instead of the RenderManager APIs that were used). So in init()


    public void init() {
        ...
        SessionRenderer.addCurrentSession("userGroup"); 
    }

And at the end of saveButton_processAction():


public void saveButton_processAction(ActionEvent ae) {
        ...
        SessionRenderer.render("userGroup"); 
    }

Scala Gaining Ground

Matt Dudbridge — Tue, 7 Jul 2009 11:09:52 -0400

Taken from James Strachan's blog:

”Given that Mr Java, Mr JRuby and Mr Groovy are all tipping Scala as javac‘s long term replacement, there might be something in it.”

Looks like Scala could soon be taking over!

Scala has some interesting features, not least that it merges object-oriented and functional languages into a single paradigm. Scala programs run on the Java VM and are byte code compatible with Java so you can make full use of existing Java libraries and existing application code.

Scala code is claimed to be as fast as Java, with the added benefit that code sizes are typically reduced by a factor of two or three.

JAVAWUG BOF 50 Summertime!

Peter Pilgrim — Tue, 7 Jul 2009 08:07:23 -0400

JAVAWUG BOF 50 Summertime!

Birds-of-a-Feather 50
Tuesday, 21^st July 2008
Skills Matter, London, UK

Dear All

I would like to formally announce that JAVAWUG (Java Web User Group) is holding the Fifty Birds-of-Feather (Meet-up 50) at Skills Matter on Tuesday, 21^th July 2009 from 18:30 until 20:30.

(Creative Commons Attribution, John Schneider, JSchneid Flickr: The RCA 40A)

It is summer time again in London. Another year and another step in the pertual change of progress: let us consider the state of the art please. We have a bunch of wonderful technologies awaiting our pleasure of development, including OpenJDK 7, JDK 7, Scala, Groovy, Grails, JavaFX, Griffon, SEAM Framework, JavaServer Faces, Fan, JRuby, Jython and many others in known use, if not yet common use. It feels like a wonderful summer again in terms of software development and design.

(Creative Commons Attribution, Nancy Waldman, nuanc Flickr: red summer)

Context

Whither Java? Are we facing a winter of discontent? Will it be a period of autumn, malnutrition of innovation, fragmentation and digital anti-socialism, which may in turn transform in to blustery winds of disharmony and technological market dislocation? In this [financial and] economic environment, we now need to learn new skills as fast as possible. This is a need. The changes in Java are slowing down and this happening coindentally with the market downtown. Developers are asking themselves the question: Am I invested enough in the right technology? Should I keep betting on Java? In fact, the JDK engineering team are currently only concerned with small changes to the Java langauge, Project Coin and Jigsaw. All of these, former, subjects are currently controversial topics and warrant further discussion than I have space here. Clearly many developers want extreme change in Java development, some have already left the platform to move on to Ruby and C# (dot net) in order to find it. Every one knows that is olde news. A lot of us have stayed with the Java platform. We are the loyal ones. Why? The new news is what exactly going to happen to those of us, who through love, passion or just professional need, stayed with the Java platform? Without any doubt the Java language and platform will remain important for another decade, at least. A grounding in programming Java is still essential to any computer science student graduating this year, still the platform is expanding with new brand new possibilities. It is pretty clear to most of us in the business that the question is really, Java and X and just what is that X-factor, the other thing called X? What technology do we really want to invest our precious time and energy to learn other than Java. This brings me to point of this entire discourse, and I know you have probably seen this inquiry before, is this really the end of summer of Java? Is this the season of Java's autumn coming to us sooner or much later? [This all reads like good prose for an AudioBoo to me *PP*]

(Creative Commons Attribution, Pheonix,AZ, fparking [at] gmail.com, freeparking Flickr: dying flowers)

Talks

What are the talks about?

Once again, as did in BOF 48 Celebrate! Five Year Anniversary, BOF 43 Open Mike , we are turning the event over to an "Open Mike" session. You can volunteer to talk about any related Java Virtual Machine technology for up to 15 minutes or general software architecture and practice. You must submit your talk to the organisers (Peter Pilgrim, Emin Tatosian) before the event. All you will need is a laptop with DVI connection to a projector, dutch courage and, most importantly, passion to deliver.

Caveat Emptor. We are going to strictly limit the time of each talk to strictly 20 minutes and we have room for three or four slots.

In summary, you can talk about:

A technology that runs on the JVM or
Software architecture and practice in your organisation

There is a very short time to go the event. So get your presentation in now. Send an email to the organiser right now! Comment on the blog!

Prizes

Java Rebel (http://www.zeroturnaround.com/javarebel/ ) and JetBrains IDEA 8.1 (http://jetbrains.com/ ) Licene Giveaways.

Slot 1

Time: 18:40-19:00

Author: Peter Pilgrim
Subject: Essential JavaFX Mix with XStream, Jersey and Nelson FX
URL: http://jroller.com/peter_pilgrim/the_nelson_framework/

Abstract: JavaFX 1.2 was released during JavaOne 2009 and has improved functionality including a brand suite of UI controls. These standard controls are an important contribution in order to developers to build Enterprise application. Peter Pilgrim talks about the new controls and how to connect a JavaFX application to a remote server application. Generally JavaFX client side application can call web services with relative ease. On the server side several developers are writing RESTful end points with the new JAX RS framework, Project Jersey is an example of JAX-RS (JSR 311) implementation. Peter Pilgrim will also talk about using the XStream framework in order to quickly produce XML output. Recently Peter open sourced the Nelson Framework for JavaFX.

Slot 2

Time: 19:05-19:25

Author: Neil Bartlett
Subject: What's New Eclipse 3.5 Gallileo?
URL: http://www.eclipse.org/galileo/

Abstract:

Slot 3

Time: 19:30 - 19:50

Author: Mike Burton
Subject: Integrating Javascript and JBoss Seam

Abstract: For a recent requirement one of my web applications needed to know the client/browser PC's screen resolution. This talk will show how to do this using Javascript, Richfaces/Ajax4Jsf, Facelets and JBoss Seam.

Slot 4

Time: 19:55-20:15

Author: Who
Subject: TBC
URL:

Abstract

Slot 5

Time: 20:20-20:35

Author: Who
Subject: TBC
URL:

Abstract

Celebrate!

The Java Web User Group is five years this year! We have also reach the half-ton milestone in birds-of-a-feather events. It is time to celebrate again.

After Party

We will be definitely heading to the pub afterwards and we will find somewhere to eat as well, if required.

If we are lucky, we will probably get sponsorship for Pizzas

Biographies

Who are the speakers?

Peter Pilgrim

Most of you already know about Peter, he is the founder and organiser of the JAVAWUG. He has a lot of J2EE experience under the belt for several years. Recently, he has been really interested in Sun's vision to "reinvigorate the desktop" with JavaFX. Peter is a Sun Certified Java Architect for the Java EE 5 platform. He presented a quickie session at Devoxx 2008 "JavaFX: Animation, Timelines and Collision Analysis For Games" .

Registration

The address is:

Skills Matter Limited
1 Sekforde Street
LONDON EC1R 0BE
Phone: 020 7107 2620
Fax: 020 7107 2621

If you would like to attend:

Please REGISTER so that you can be added to the SECURITY DETAIL with SkillsMatter.
If you aren't a JAVAWUG member why not join the JAVAWUG at Google Groups?

For problems, send an email to peter (dot) pilgrim (at) gmail (dot) com and emin (dot) tatosian (at) gmail (dot) com.

Here is some relevant travel information:

By Underground: -
Farringdon : Come out the station turn left and left again. Walk up Turnmill Street, cross the Clerkenwell Road. At the road head to the right on Aylesbury St. Walk past the Crown Tavern pub and you will see the building 1 Sekforde. You can't really miss it.
Map: Google Maps Link to 1 Sekforde Street

The venue has graciously been organised by Skills Matter team. We all appreciate this generous gift.

JAVAWUG.com

JAVAWUG BOF Videos by Peter Pilgrim is licensed under a Creative Commons Attribution-Non-Commercial-Share Alike 2.0 UK: England & Wales License.

Based on a work at http://jroller.com/javawug.

Media Copyright Notice

JAVAWUG BOF Events are video recorded, edited and published freely. We normally record the speaker and administrators. You can find examples on Vimeo and Google Video. On the rare occasion we do record some audience members. Please let us know if you personally would rather not been filmed. We reserved Some of the Copyright 2008/2009 ©© JAVAWUG Video Productions, Creative Commons License (Attributions: Attribution (by): Licensees may copy, distribute, display and perform the work and make derivative works based on it only if they give the author or licensor the credits in the manner specified by these conditions.).

This is Peter Pilgrim, Out.

(John Schneider Photograph, Creative Commons Attribution, Flickr 2007. The RCA40A microphone was introduced in the early 1930'. It was the first ribbon ("velocity") microphone on the market, to be succeeded by RCA's famous 44BX and 77DX microphones.)

DDD @ JavaZone

Janniche Haugen — Mon, 6 Jul 2009 18:41:43 -0400

My talk about domain driven design and good object orientation was accepted at JavaZone. I know what I'll be doing this summer :)

Una mujer tras las cortinas

Julian Rivera Pineda — Mon, 6 Jul 2009 14:39:50 -0400

http://www.renuevodeplenitud.com/reflexiones-una-mujer-tras-las-cortinas.html

Cosa Seria Lula

Julian Rivera Pineda — Mon, 6 Jul 2009 14:11:03 -0400

http://www.flickr.com/photos/webmink/3668906393/in/photostream/

Lula's Java Ring

Julian Rivera Pineda — Mon, 6 Jul 2009 14:06:36 -0400

Lula's Java Ring

GRAG 1.1 Released

Mark Fortner — Mon, 6 Jul 2009 11:59:54 -0400

I've been blogging about GRAG recently, and the latest version 1.1 was released. Thanks Rudie (and the rest of the GRAG team)!

SpringFramework Meeting 2009 Photos

Massimiliano Dessì — Mon, 6 Jul 2009 10:30:47 -0400

Mr. Alef Arendsen, SpringSource JTeam "SpringFramework 3.0"

Mr. Luca Marrocco, Exmachina "Google App Engine"

Mr. Massimiliano Dessì, Pronetics Sourcesense "The hidden gems of SpringSecurity"

Mr. Mario Fusco, Exmachina "Lambdaj"

Mr. Piergiorgio Lucidi, Sourcesense "A success story: Spring in Alfresco ECM"

Generating Grails Apps From UML Models

Mark Fortner — Mon, 6 Jul 2009 10:19:53 -0400

In my previous blog entry I described how to reverse engineer a Grails application using GRAG (the GRails Application Generator). In this entry, I'll walk through a couple examples of how to create a GRAILS application using a UML model.

GRAG has the ability to export a project configuration as a UML model, by simply selecting the File > Export UML Model menu item. This generates an XMI file that you can then import into your favorite UML tool. In my case, I loaded the file into ArgoUML.

When you load an XMI file into ArgoUML, the first thing that you notice is that the model doesn't include any diagrams. So if you're expecting to see diagrams, at this point you'll be pretty disappointed. The second thing that you notice is that the model also includes stereotypes like DataSource, Entity, Primary, Key and Required. Your model is automatically created in a package called "model" since GRAG doesn't support packages (or "namespaces" in UML parlance) yet.

To add the Entities to a class diagram, simply select the Entities from ArgoUML's project pane (on the left side of the window) and then right-click and select Add to Diagram from the popup menu. The Entities and all of their relationships will be added to the diagram. If you select Arrange > Layout, ArgoUML will automatically layout the classes on the page. You may then want to spend a little time cleaning up the diagram.

At this point you have a pretty functional diagram that shows the relationships between the Entities, and gives you a starting point for your own modeling efforts. You can now edit the diagram to your heart's delight, add new classes, change the packaging, etc. You can save the project as an ArgoUML project, and then re-export the XMI with your new changes. You then open the XMI file in GRAG and re-generate your application.

Creating Your Own Profile
If you're going to be creating your own models from scratch you'll need to export the stereotypes from an existing GRAG model. This package of types and stereotypes is called a profile. To create a profile:

Export the model as an XMI file from ArgoUML.
Create a new ArgoUML project.
Import the profile by right-clicking on the "Profile Configuration" folder in the ArgoUML project pane.
Click the "Load profile from file" and select the XMI file that you created in step 1. The grag profile will now appear in the dialog box.
Click on the grag profile and click the ">>" button to add the profile to the list of Active Profiles, then click the OK button.
Back in the Profile Configuration folder you should now see grag listed as one of the profiles. If you open this profile folder, you'll see the DataSource, Entity and other Grails-specific stereotypes listed.

Creating Your Own Models
To create your own models, start by importing the grag profile into your current project (steps 3-5 in the previous section). Add any classes that you want to your model. To make your model useable by GRAG, you'll need to:

Apply the Entity stereotype to each class that you want to be able to use as a domain class.
Apply the PrimaryKey stereotype to the appropriate key fields in your classes.
Apply the Required stereotype to any field that is not nullable.

When adding relationships between entities you'll need to use the foreign-field, multiplicity, and bidirectional tag data fields to the associations. You can use an existing model to give you some examples on how to define these relationships. To draw the relationship, you click on the association icon (shown below in red). You may need to click the down arrow next to the icon in order to switch between different association types.

That's pretty much all there is to it. You can now create your own Grails applications by either reverse engineering an existing database, or by generating an application from a de novo model.

[OT] 2 year old smoking a cigarette

evans — Mon, 6 Jul 2009 09:55:07 -0400

Wow thats disgusting a child so young smoking…….to think they believe it is funny i say social services all the way!!!!

Spring Meeting Cagliari Slides and Photos

Massimiliano Dessì — Mon, 6 Jul 2009 05:56:12 -0400

Slides and photos of the Spring Italian User Group Meeting , 27 June 2009 in Cagliari

Slides

Photos

User IdleMonitor

Cagatay Civici — Mon, 6 Jul 2009 04:32:39 -0400

A JSF component to monitor user actions;

http://cagataycivici.wordpress.com/2009/07/06/user-idlemonitor/

Content Negotiation using Spring MVC's ContentNegotiatingViewResolver

Eyal Lupu — Mon, 6 Jul 2009 03:37:43 -0400

Hi all,

One of the new features in Spring 3.0 is REST support, REST clients can use the restTemplate class and servers have support as part of the MVC framework. One of the new interesting features is content negotiation using the a new view resolver - ContentNegotiatingViewResolver. Lately I was invited to give a lecture about the new Spring 3.0 features and I prepared a detailed HOWTO example (if you want to skip the theory go to here) of REST content negotiation which I decided to load to my blog, here it is

What is Content Negotiation?

Sometimes different HTTP clients would like to get different representations of a the same resource, for example the resource http://localhost/app/rest/users will list all of the users in a specific server - however one client would like to get the result as a XML document, another in a JSON format and the third as a human readable fancy HTML table - the process in which a client notifying the server about the preferred format (or formats) is named "content negotiation".

Content negotiation is part of the HTTP specification which defines two types of content negotiation - "server-driven negotiation" and "agent-driven negotiation". The scenario implemented by ContentNegotiatingViewResolver is server-driven negotiation. In abstract the specification defines server-driven negotiation as the following sequence:

The agent (e.g., a browser) can include the following HTTP headers in a request: Accept, Accept-Charset, Accept-Encoding, Accept-Language, and User-Agent.
Base on these headers the sever selects the best format (based on the server's internal logic) that match these criteria and send it to the client

It is important to notice that the specification recommend using the above headers but it also states that: "However, an origin server is not limited to these dimensions and MAY vary the response based on any aspect of the request, including information outside the request-header fields or within extension header fields not defined by this specification." (here). I mention it since Spring's ContentNegotiatingViewResolver is doing just that.

The ContentNegotiatingViewResolver

The ContentNegotiatingViewResolver is a view resolver which instead of dispatching a view it delegates to another view resolver. The "secret" is in the way it decides to which resolver it should delegate to. The ContentNegotiatingViewResolver determines the client's preferred presentation form (a.k.a., the content or media type) based on the following algorithm:

First it checks the request path extension (for example .../showUsers.xml vs. .../showUsers.pdf) against the ContentNegotiatingViewResolver defaults to determine the media type
If there was no match on step 1, and if JAF is present on the environment it uses the FileTypeMap (javax.activation.FileTypeMap) to get the media type using the requested filename.
As a last option it uses the Accept header

Once a media type was determined it asks each of the other view resolvers for a "candidate" view and checks to see if this view supports the requested media type, if so the request is delegated to the appropriate resolver (not to the candidate view, but to the resolver).

From steps 1 and 2 on above we can see that, as motioned before, Spring uses variant of request attributes to try and guess the media type and it doesn't stick only to the accept header.

Example

Environment

Spring 3.0.M3
Jetty 6.1.14

In my example I have a "user details" service that can be queried for users using username prefixes, I would like to render the output as XML, HTML and a "toString" format (a format I "invented" for the example in which I renders the user objects using the toString() method). My controller is as simple as it can be:

import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Map.Entry;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class UsersController {

  private Map<String, UserDetails> users = new HashMap<String, UserDetails>();

  {
    UserDetails user = new UserDetails("eyal", new Date(), true);
    users.put(user.getName(), user);

    user = new UserDetails("john", new Date(), false);
    users.put(user.getName(), user);

    user = new UserDetails("emily", new Date(), true);
    users.put(user.getName(), user);

    user = new UserDetails("mark", new Date(), false);
    users.put(user.getName(), user);
  }

  @RequestMapping("/users/{namePrefix}")
  public String getUsers(@PathVariable("namePrefix") String prefix, Model model) {

    Collection<UserDetails> result = new LinkedList<UserDetails>();

    for (Entry<String, UserDetails> entry : users.entrySet()) {
      if (entry.getKey().startsWith(prefix)) {
        result.add(entry.getValue());
      }
    }
    model.addAttribute("users", result);
    return "usersListView";
  }
}

I map the controller using the @RequestMapping annotation to server any request which ends with any of the following patterns:/users/{namePrefix}, /users/{namePrefix}.*, and /users/{namePrefix}/. In my web.xml I map Spring's DispatcherServlet to the /rest/* url pattern so, for example, http://localhost:8080/<context>/rest/users/e, http://localhost:8080/<context>/rest/users/e.xml and http://localhost:8080/<context>/rest/users/.toString are all valid urls that will invoke my controller.

The controller returns the "usersListView" as the name of the next view to dispatch, technically I could do the content negotiation myself by adding the controller some logic that dispatches different views based on the request - for example if the file extension was '.xml' then I would try to dispatch the "usersListViewXML" and if it was '.htm' I would try to dispatch the "usersListViewHTM" view. But in a big application this can be very complicated to maintain - this is where the ContentNegotiatingViewResolver can help us by externalizing this logic. My controller will always return the "usersListView" as the next view but the actual view will be resolved using data from the actual HTTP request. Here is my application context:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:context="http://www.springframework.org/schema/context"
   xmlns:p="http://www.springframework.org/schema/p"
   xsi:schemaLocation="http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-2.5.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

<context:component-scan base-package="**/eyallupu/**" />

<bean id="contentNegotiatingViewResolver" 
   class="org.springframework.web.servlet.view.ContentNegotiatingViewResolver"
   p:order="#{T(org.springframework.core.Ordered).HIGHEST_PRECEDENCE}">
      <property name="mediaTypes">
         <map>
            <entry key="xml" value="application/xml" />
            <entry key="tostring" value="text/toString" />
            <entry key="html" value="text/html" />
         </map>
      </property>
</bean>

<bean id="marshallingViewResolver" class="com.jroller.blogs.eyallupu.rest.views.SingleViewViewResolver"
   p:order="#{contentNegotiatingViewResolver.order+1}">
      <constructor-arg>
         <bean class="org.springframework.web.servlet.view.xml.MarshallingView">
            <constructor-arg>
               <bean class="org.springframework.oxm.xstream.XStreamMarshaller" />
            </constructor-arg>
         </bean>
      </constructor-arg>
</bean>

<bean id="toStringViewResolver" class="com.jroller.blogs.eyallupu.rest.views.SingleViewViewResolver"
  p:order="#{marshallingViewResolver.order+1}">
      <constructor-arg>
         <bean class="com.jroller.blogs.eyallupu.rest.views.ToStringView"
            p:contentType="text/toString" />
      </constructor-arg>
</bean>

<bean id="urlBasedViewRewsolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver"
   p:prefix="/WEB-INF/jsp/" p:suffix=".jsp" p:order="#{toStringViewResolver.order+1}" />

</beans>

In the configuration above it is worth noticing the following

Registration of new media type

I set a value into the 'mediaTypes' property which maps file name extensions into media types. In traditional configuration I could skip it and let Spring use the defaults (as described in the beginning of this entry - filename extensions, JAF, and accept header) but since I wanted to illustrate how do I register a new media types (text/toString in this example) I set a value into this property. Using this configuration any request ends with '.toString' (case insensitive) will be mapped to the 'text/toString' media type.

The target View Resolvers

Other important components in this configuration is the view resolvers. I create three view resolvers - two of the SingleViewViewResolver type (more on that soon) and one is an instance of Spring's InternalResourceViewResolver. The ContentNegotiatingViewResolver will automatically locate these three resolvers and delegate to the first one that can serve a view with the required content type. The order of the resolvers is important and must follow the following rules:

The ContentNegotiatingViewResolver itself must be with the highest precedence (I set that using the #{T(org.springframework.core.Ordered).HIGHEST_PRECEDENCE} expression)
If more than one resolver can serve the same content type I must decide on their order to set my preferences

In my example I used Spring EL (SpEL) to explicitly set the order for the different resolvers, starting with the ContentNegotiationResolver as the first and continuing with the marshalling, toString and URL based view resolvers.

What is the SingleViewViewResolver?

I have two "generic views" - toString and XML, both are generated automatically using a view instance (ToStringView and MarshallingView) without a need for any concrete JSP or other template. I wanted to have an easy way to dispatch these views based on their bean names. But here is a catch - my controller returns the "usersListView" as the next view, but I can have only one bean named "usersListView" in my context, meaning that I cannot use the BeanNameViewResolver. One alternative - which was mentioned earlier - is to return a custom view name from the controller ("usersListViewXML" and "usersListViewToString") and to create two different beans (or actually to alias two generic beans with the concrete view name - for example a "toStringView" generic bean can be aliased as "usersListViewToString"). I choose a different way: I wrote a small view resolver which wraps one view and always returns it. By wrapping my views in a resolver I can register them into the ContentNegotiatingViewResolver and have them participating in the view selection process.

Putting It All Together

Let's assume that the following request arrives to my server: http://localhost:8080/spring30/rest/users/e.xml. What would happen?

The DispatcherServlet will forward the request to my controller (UsersController)
The users controller will find all of the users starting with 'e' put them in the model and select the "usersListView" as the next view
The first resolver Spring MVC consults is ContentNegotiatingViewResolver (since it has the highest priority)
The resolver figures out that the request media type is 'application/xml' and it starts to iterate and interview other resolvers (by their order)
The first resolver interviewed is the instance of SingleViewViewResolver which wraps the MarshallingView, it returns that view
The ContentNegotiationViewResolver checks to see if that view supports the 'application/xml' media type - it is
The request is forward to the SingleViewViewResolver which will forward it to the MarshallingView
The marshaling view creates the XML and returns it to the client

If the request would end with .html both instance of SingleViewViewResolver would fail to return a view which satisfies the need for a 'text/html' media type and the third view resolver would be invoked. This resolver dispatches the request to 'usersListView.jsp' which renders the response as an HTML page.

Demain Soirée RIA (Flex et JavaFX) au ParisJUG

Le Droff — Mon, 6 Jul 2009 03:32:39 -0400

Je serai présent demain soir au Paris JUG, le groupe d'utilisateurs du langage Java qui se retrouve mensuellement à Paris.

La conf. aura lieu dans les locaux de l'ISEP à partir 19h30.

N'oubliez pas de vous inscrire !

Ma présentation vous donnera (je l'espère ) un bon aperçu des possibilités offertes par le framework Flex et son écosystème pour la création de RIA d’entreprise dans un "environnement" Java/JEE, ceci notamment à travers démonstrations et découvertes des dernières nouveautés des solutions Adobe : Spring-Flex, LCDS3, Flex4, FlashBuilder4 et FlashCatalyst).

A demain !

JavaSpace into JavaEE: the SemiSpace example

Dominique De Vito — Mon, 6 Jul 2009 03:01:25 -0400

I have written into my post 7 good reasons to have a second look at Jini, and what is coming next, into the conclusion: "I would like to see a JavaSpace-like included into Java EE". Well, the JavaSpace specification is not yet part of Java EE. But I have seen recently an interesting announcement: SemiSpace: an open source JavaSpaces inspired tuple space: "SemiSpace is a light weight open source interpretation of Tuple Space / Object Space based on ideas from JavaSpaces. The library can be included as single, stand alone, space in a Java SE 1.5.x (or greater) application, or clustered with Terracotta. The source and binaries can be found in the Maven repository, and can be included in your project with a simple Maven dependency".

The more interesting point is: "SemiSpace does not need Jini installed... as SemiSpace does not use Jini". Quite a good way to spread JavaSpace technology.

What I really like with JavaSpace is that it matches quite well different use cases. I have already mentioned one in JavaSpaces, an interesting technology for doing ESB or SOA. The workflow use case is another good candidate for leveraging JavaSpace technology:
- the current workflow context could be put into a JavaSpace, as it provides a (simple) storage mechanism,
- workers could be notified through events when context objects into the JavaSpace match a given (state) template,
- only one worker can take a (context) object into a JavaSpace, then only one workflow transition could be executed at any time.

It looks like quite better than defining a mapping O/R for saving the context object into a relational database, using a custom mechanism for pooling context changes, and supporting a locking mechanism for prohibiting concurrent access.

Structure and Interpretation of Computer Programs

Julian Rivera Pineda — Mon, 6 Jul 2009 02:50:30 -0400

http://mitpress.mit.edu/sicp/full-text/book/book.html

GfxBuilder update: custom nodes

Andres Almiray — Mon, 6 Jul 2009 00:08:02 -0400

A quick update of what is now available on GfxBuilder:

Border paints and multi paints are back! here is a small how-to on paints.
All strokes classes from Jerry Huxtable's collection are back too, plus a few additions from Jeremy @ Java Graphics: Code Snippets. Here is another small how-to on strokes.
Most important of all: Custom Nodes!

ut I'm very excited about the availability of custom nodes because making them in the past was nigh impossible, thanks in part to AST transformations that no longer is true. Let's revisit the Sphere multi-paint example, if you recall the code from than sample (follow the paint tutorial for a quick memory refreshment) you will notice that a sphere can be drawn using a circle and 3 gradients, well here is the updated version using custom nodes, first an image is worth a thousand words

Now for the code itself

import groovy.swing.SwingBuilder
import griffon.builder.gfx.*
import griffon.builder.gfx.swing.GfxPanel
import java.awt.Color

class SphereNode extends CustomGfxNode {
  @GfxAttribute(alias="r") double radius = 90
  @GfxAttribute double cx = 100
  @GfxAttribute double cy = 100
  @GfxAttribute Color base     = Colors.get("blue")
  @GfxAttribute Color ambient  = Colors.get(r: 6,  g: 76,  b: 160, a: 127)
  @GfxAttribute Color specular = Colors.get(r: 64, g: 142, b: 203, a: 255)
  @GfxAttribute Color shine    = Colors.get("white")

SphereNode() {
    super("sphere")
  }

Drawable createNode(GfxBuilder builder) {
    double height = radius * 2
    builder.group(borderColor: 'none') {
      circle(cx: cx, cy: cy, radius: radius, fill: base)
      circle(cx: cx, cy: cy, radius: radius) {
        multiPaint {
          radialGradient(radius: radius) {
            stop(offset: 0.0f, color: ambient)
            stop(offset: 1.0f, color: rgba(alpha: 204))
          }
          radialGradient(cy: cy + (height*0.9),
                         fy: cy + (height*1.1)+20,
                         radius: radius) {
            stop(offset: 0.0f, color: specular)
            stop(offset: 0.8f, color: specular.derive(alpha: 0))
            transforms{ scale(y: 0.5) }
          }
          radialGradient(fit: false, fx: 55, fy: 35, radius: height/1.4){
            stop(offset: 0.0f, color: shine.derive(alpha:0.5))
            stop(offset: 0.5f, color: shine.derive(alpha:0))
          }
        }
      }
    }
  }
}

def gfx = new GfxBuilder()
def node = gfx.group() {
  antialias true
  background(color('white'))
  customNode(SphereNode)
  customNode(SphereNode, cx: 300,
    base: color('red'),
    ambient:  Colors.get(r: 160, g: 76,  b: 6,  a: 127),
    specular: Colors.get(r: 203, g: 64, b: 64, a: 255))
  customNode(SphereNode, cy: 300,
    base: color('green'),
    ambient:  Colors.get(r: 160, g: 76,  b: 6,  a: 127),
    specular: Colors.get(r: 64, g: 250, b: 64, a: 255))
  customNode(SphereNode, cx: 300, cy: 300,
    base: color('orange'),
    ambient:  Colors.get(r: 160, g: 76,  b: 6,  a: 127),
    specular: Colors.get(r: 203, g: 203, b: 64, a: 255))
}

def swing = new SwingBuilder()
swing.edt {
  frame(title: "Sphere", size: [410,430], visible: true) {
    panel(new GfxPanel(), id: "canvas", node: node)
  }
}

The SphereNode exposes 7 attributes to the outside world using @GfxAttribute. This particular annotation is @Bindable's long lost sibling, it not only performs the same task @Bindable does (making a property an observable one) but it also is able to write an aliased property, this means you can either set a value for the radius: property or r: property (shortcuts!), it doesn't matter as the backing field will be updated accordingly. The node sets some default values for those attributes, those values match the settings for the blue sphere. Moving on to the actual drawing code of the node, it is pretty much the same one found in the painting how-to plus a few tweaks to have all gradients be relative to the node's location. Notice that the radial gradients are now aware of its host's dimensions, this is why setting values for cx: and cy: is now optional.

Drawing 4 spheres is just a matter of setting the appropriate coordinates (cx,cy) and tweaking some of the colors, otherwise we will have a drawing of 4 blue spheres in the same place! There are two ways for adding a custom node to an scene, by defining the node's class as the value of customNode() or passing an instance of a subclass of CustomNode to customNode(), in the end there is not much difference, the builder makes sure your nodes have the proper attribute values set before they are rendered.

Keep on Groovying!

The future of the programming language: an interesting summarizing presentation

Dominique De Vito — Sun, 5 Jul 2009 16:22:19 -0400

coder-friendly has written about What about Java? after watching the video of "The future of the programming language". This presentation was led by Anders Hejlsberg, the architect of C#; quite an interesting presentation for getting a summary.

coder-friendly gave a nice summary about the video:
(1) the Domain Specific Language (internal and external DSL)
(2) the declarative aspect (concentrate on the 'what' and not on the 'how')
(3) the convergence between static and dynamic languages
(4) the emergence of functional languages (imperative ones are not appropriated to multi-threading processing)

I am quite inline/agree with the 4 points. So, I like this informative summary.

Let's enter into more details:
(1) almost everybody has noticed the rise of DSL out there. I can add some languages are more suitable than others for building DSL, like the following ones derived from Java: Groovy and Scala
(2) the introduction of annotations, into a mainstream language like Java, is the beginning of the declarative road
(3) static and dynamic languages do converge, and Anders Hejlsberg mentioned type inference is helping to fill the gap between typeless programming for dynamic languages and strong typing for static languages; for another example, read my post about JS and Java: A false piece of news may become real as Java and JS move closer
(4) and, yes, functional languages do emerge. Java, and more than that, C#, have more and more functional features. I have written old posts (in 2005) about it: Thoughts about Java, C# future and OCaml (?) relationships, and More ramblings on programming languages and more recently Functional programming on-going adoption as a side-effect

Least Squares

David Shay — Sun, 5 Jul 2009 16:12:38 -0400

A month ago, I posted an entry about Quadratic Interpolation. Reading further my math book, I found an explanation about the method of Least Square approximation, where I could improve further my program by giving any number of points, and finding a polynomial function of a given degree that would go as close as possible to all the points. Using 9 points and a polynomial function of degree 3, I have the following drawing:

The theory is to solve the following matrix system: A^TAx = A^Tb

Here, the matrix A contains on each line the X values of the points at increasing power (0 at column 0, 1 at column 1, ...) until the desired power of the polynomial function. The vector b contains the Y values of the points. For the calculation, I only need to replace my Parabole class with another one I called GeneralEquation:

import java.awt.Point;
import java.util.Arrays;
import static ethdsy.parabole.GeneralParameters.*;

public class GeneralEquation
{
   private LinearSolve solver = new LinearSolve();
   private Matrix matrix = new Matrix(NumberOfPoints, DegreeOfEquation + 2);
   
   public void solveEquation(Point[] points, double[] sol)
   {
      assert points != null && points.length == NumberOfPoints;
      assert sol != null && sol.length == DegreeOfEquation + 1;
      
      //Create Matrix A
      double[][] matA = new double[DegreeOfEquation + 1][];
      //first line of constant
      matA[0] = new double[NumberOfPoints];
      Arrays.fill(matA[0], 1.0);
      
      //second line with X
      matA[1] = new double[NumberOfPoints];
      for (int i = 0; i < NumberOfPoints; i++)
         matA[1][i] = points[i].x;
      
      //other lines with power of x
      for (int i = 2; i <= DegreeOfEquation; i++)
      {
         matA[i] = new double[NumberOfPoints];
         for (int j = 0; j < NumberOfPoints; j++)
            matA[i][j] = matA[i-1][j] * points[j].x;
      }
      
      //Calculate AtA
      computeAtA(matA);
      
      //calculate Atb
      computeAtb(matA, points);
      
      //solve
      solver.solve(matrix, false);
      
      int lastCol = matrix.getNbCol() - 1;
      for (int i = 0; i < sol.length; i++)
         sol[i] = matrix.get(i, lastCol);
   }
   
   private void computeAtb(double[][] matA, Point[] points)
   {
      int col = DegreeOfEquation + 1;
      for (int i = 0; i < matA.length; i++)
      {
         double[] row = matA[i];
         double sum = 0;
         
         for (int j = 0; j < points.length; j++)
         {
            sum += row[j] * points[j].y; 
         }
         
         matrix.set(i, col, sum);
      }
   }

   private void computeAtA(double[][] matA)
   {
      for (int iA = 0; iA < matA.length; iA++)
      {
         double[] rowA = matA[iA];
         for (int iAt = 0; iAt < matA.length; iAt++)
         {
            double[] rowAt = matA[iAt];
            double sum = 0.0;
            
            for (int j = 0; j < rowA.length; j++)
            {
               sum += rowA[j] * rowAt[j];
            }
            
            matrix.set(iA, iAt, sum);
         }
      }
   }
}

This solves the system of equations by giving the coefficients of the polynomial expression in the last column of my matrix. For the user interface, I replaced my ParabolePanel with a GeneralEquationPanel, which is only a generalization to degree N:

import java.awt.Color;
import java.awt.Graphics;

import javax.swing.JPanel;

public class GeneralEquationPanel extends JPanel
{
   private double[] equation = new double[GeneralParameters.DegreeOfEquation + 1];

   GeneralEquationPanel()
   {
      setOpaque(true);
   }

   @Override
   protected void paintComponent(Graphics g)
   {
      super.paintComponent(g);
      
      g.setColor(Color.BLUE);
      
      int yPrevious = (int) equation[0];
      for (int i = 1, n = getWidth(); i < n; i++)
      {
         double v = 0.0;
         int degree = 1;
         for (double coeff : equation)
         {
            v += coeff * degree;
            degree *= i;
         }
         int y = (int)v;
         g.drawLine(i-1, yPrevious, i, y);
         yPrevious = y;
      }
   }
   
   public void SetEquation(double[] eq)
   {
      this.equation = eq;
      repaint();
   }
   
}

The shortcomings of my solution is that I use the coordinates in pixel for the calculation, and if you try using a power above 3, the A matrix values will overflow. I should divide the values to be in a better range. However, you can have a look at the result here:

Introduction to SmartGWT Enterprise Edition (EE)

Sanjiv Jivan — Sun, 5 Jul 2009 11:22:24 -0400

The SmartClient folks have released SmartGWT Enterprise Edition. The SmartGWT EE Showcase can be viewed here and the latest version 1.2 of the distribution can be downloaded here.

I recently spent some time understanding how SmartGWT EE works and the functionality it provides. I'll attempt to cover the key features of SmartGWT EE in this blog.

SmartGWT LGPL itself is one of the most feature complete libraries in terms of widgets, feature-set and databinding capabilities. I had written an introduction to it when SmartGWT was first released. Please read it if you haven't already done so as all the concepts covered in that post apply to SmartGWT EE as well. SmartGWT EE builds on SmartGWT and takes integrating the databound components to your Java based backend to the next level.

So what exactly is SmartGWT EE? In a nutshell, SmartGWT EE provides a whole lot of features that allow accelerated server side integration with SmartGWT's visual components. Fully functional CRUD screens, with inline editing, virtual pagination, type validation, ability to create new records, deletes, updates, advanced filtering capabilities, file export and upload can be build with as little as 25 lines of client side SmartGWT code, and a simple XML based DataSource descriptor file that lives on the server side. For the simple CRUD usecase zero lines of server side code is required to be written by a developer. However the beauty of SmartGWT EE is that it not only makes the simple cases simple, but also handles real world usecases very elegantly and developers can add additional business logic to take place before or after each operation is executed. (Details are covered below). As a result, junior developers can get productive right away in literally a matter of hours to a day, and still produce results similar to that of a senior developer.

There are wizards in other frameworks that help you get jump started with a simple CRUD web app, however they generate a lot of code and artifacts which become hard to maintain once modifications or enhancements are required. With SmartGWT EE, there is zero generated application code that the developer needs to maintain.

Here are some of the key features supported by SmartGWT EE. You'll notice that a majority of these features / functionality are required by most Enterprise applications, regardless of the domain or nature of the application.

Authentication and Re-login : Almost all enterprise applications require users to be authenticated. With SmartGWT EE, a user can specify that a DataSource as a whole or it's individual operationBindings, or particular fields are accessible only to authenticated users or to users with certain roles, where the roles and authentication status comes from JAAS or J2EE security. For applications that use a session timeout, a background RPC may occur with an expired session. One would typically prompt the user to relogin, but SmartGWT EE goes further by suspending the attempted transaction and presents a modal dialog to re-authenticate the user. On successful authentication, the original transaction is resumed without loss of data or context.
CRUD screens are screens to create, read, update and delete entities. Such screens may be direct views over a database table, or over domain classes that may have business logic that is executed when CRUD operations are invoked. Datatype and business validation rules may apply to any given field. In SmartGWT EE creating such screens it trivial. Have a look at the Basic Connector sample that supports the various CRUD operations along with filtering.

Here's the DataSource descriptor :
<DataSource ID="worldDS" serverType="sql" tableName="worldDS" testFileName="/ds/test_data/world.data.xml" > <fields> <field name="pk" type="sequence" hidden="true" primaryKey="true" /> <field name="countryCode" type="text" title="Code" required="true" /> <field name="countryName" type="text" title="Country" required="true" /> <field name="capital" type="text" title="Capital" /> <field name="government" type="text" title="Government" length="500" /> <field name="continent" type="text" title="Continent"> <valueMap> <value>Europe</value> <value>Asia</value> <value>North America</value> <value>Australia/Oceania</value> <value>South America</value> <value>Africa</value> </valueMap> </field> <field name="independence" type="date" title="Nationhood" /> <field name="area" type="float" title="Area (km²)" /> <field name="population" type="integer" title="Population" /> <field name="gdp" type="float" title="GDP ($M)" /> </fields> </DataSource>
and here's the client side GWT code :
public class BasicConnectorSample implements EntryPoint { public void onModuleLoad() { final ListGrid listGrid = new ListGrid(); listGrid.setWidth(700); listGrid.setHeight(224); listGrid.setAlternateRecordStyles(true); listGrid.setDataSource(DataSource.get("worldDS")); listGrid.setAutoFetchData(true); listGrid.setShowFilterEditor(true); listGrid.setCanEdit(true); listGrid.setEditEvent(ListGridEditEvent.CLICK); listGrid.setCanRemoveRecords(true); IButton newButton = new IButton("Add New"); newButton.addClickHandler(new ClickHandler() { public void onClick(ClickEvent event) { listGrid.startEditingNew(); } }); VLayout layout = new VLayout(15); layout.addMember(listGrid); layout.addMember(newButton); layout.draw(); } }
This sample uses SmartGWT EE's SQL connector which automatically handles carrying out the CRUD operations. However you can also use Hibernate (see sample), or a combination of Spring and Hibernate (see sample). Additionally you can insert your own business logic for each operation as illustrated by the User Specific Data sample.
Master-Detail screens represent one to many relationships. Building Master Detail screens using SmartGWT EE is easy. Take a look at this Master-Detail sample. Notice how all the edits to the master entity (Order) and the detail entities (Order Details) get submitted to the server in a batch as a single RPC operation. The screenshot below is of the Order and Order Details table.

Transaction Queuing allows multiple data load or save requests from different UI components to be transparently combined into a single HTTP request with guaranteed in-order execution. Queuing also makes it simple to define transaction boundaries when data in different UI components need to be saved together. This is probably one of my favorite features that is really innovative and unique to SmartGWT EE. Consider a screen where several databound components are to be displayed. For example a Tree, a ListGrid and a Calendar. One could separately make calls to load each databound widget . This would involve multiple roundtrips to the server and affects the user experience as well. With SmartGWT EE's transaction queuing support you can add all the requests to load various databound components within a single queue, and the results are returned in response to a single RPC call. Here is a code snippet from the Transaction Queuing sample : ButtonItem findButtonItem = new ButtonItem("findButton", "Find Orders"); findButtonItem.addClickHandler(new ClickHandler() { public void onClick(ClickEvent event) { RPCManager.startQueue(); userDetailViewer.fetchData(findOrdersForm.getValuesAsCriteria()); ordersListGrid.fetchData(findOrdersForm.getValuesAsCriteria()); RPCManager.sendQueue(); } });
Ad hoc reports that are based directly on complex SQL and not necessarily mapped to business objects. Such queries may include both standard and bespoke WHERE conditions and the use of aggregate functions and a GROUP BY. Have a look at the Dynamic Reporting sample.
Export capabilities : The ability to export data from a DataSource or from DataBoundComponents like ListGrid, TreeGrid or TileGrid to Excel / CSV / XML is inbuilt and can be done using a few lines of code on the client side with no additional server side code. The exported data matches the filtered resultset if a filter was applied. Have a look at this sample. Although the sample says Export to Excel, the file format returned is CSV. Excel does open CSV files but I wish they supported exporting directly to .xls files as well.
File Upload capabilities : SmartGWT EE supports the ability to import data into a table by uploading a CSV file. Again, SmartGWT EE goes beyond the normal expectation of how files are typically uploaded and does something really smart. Upon upload, the data in the CSV file is validated by the server against the defined DataSource and records with errors are streamed back to the user and displayed in an editable grid for review and correction. Upon correcting, the user can commit the corrected records back to the persistent store. This end-to-end functionality is in-built and requires no application code. Again, it would be nice it they supported upload of .xsl files as well. Check out the Batch File upload sample here.
Communicating with an in-memory engine : In some cases you need to build a UI that talks to an in-memory server object model that is not necessarily backed by a relational database. Accomplishing this in SmartGWT EE is easy. You can write a custom DataSource class that extends a BasicDataSource and implement your own logic for the fetch, update, create and delete requests. The Custom DataSource sample illustrates this. Here's what skeleton code for a custom datasource looks like : public class UserDataSource extends BasicDataSource { // Override all four CRUD operations - create, retrieve, update and delete // (add, fetch, update and remove in SmartGWT terminology). // Note that the parameters sent by the client arrive here already converted // to Java Maps by the SmartGWT Server - there's no need to worry about // conversion to and from XML or JSON even in a custom DS implementation public DSResponse executeAdd(DSRequest req) throws Exception { .... .... } public DSResponse executeFetch(DSRequest req) throws Exception { .... .... } public DSResponse executeRemove(DSRequest req) throws Exception { Long employeeID = (Long)req.getValues().get("employeeId"); .... .... } public DSResponse executeUpdate(DSRequest req) throws Exception { Map map = req.getOldValues(); Long work = (Long)req.getValues().get("employeeId"); .... .... } }
Eliminate Data Transfer Objects (DTO) : With SmartGWT EE, your entire domain model remains unaffected and you do not need to write superfluous DTO's, worry about Hibernate lazy loading issues, managing updates, or write different service API's for each client-view use case. SmartGWT EE manages propagating changes made by the user to the server efficiently by only returning the modified fields (and not the entire record data), and the server side SmartGWT EE classes seamlessly only update the properties that were modified my the user. All the user needs to do is create a simple xml DataSource descriptor exposing the fields that need to be returned to the client. The fields can contain nested properties. Have a close look at the Data Selection sample. This example shows the SmartGWT Server's support for flattening and reconstructing hierarchical data, by use of XPaths. The ListGrid shows each user's address, city and state as if those fields were part of the user's data. In fact, this address information is held in a separate Address bean; this information is extracted from the separate bean at fetch time by the SmartGWT Server, based purely on the XPath declarations of those fields in the dataSource.
SQL / HQL Templating : If required, one can customize the SQL or HQL queries automatically generated by the SmartGWT EE SQL / Hibernate connectors directly in the DataSource definition by overriding specific clauses from the automatically generated query, without the need to write any Java code. As a result one can rapidly crank out fully functional application screens that include DataBound components without writing any Java server code. This completely eliminates the need for superfluous Service API -> DAO delegation for basic CRUD operations (Technologies like Grails also completely do away this the extra layer of delegation and API explosion which was previously considered a best-practice but now recognized as an anti-pattern by experts). The use of SQL Templating is illustrated by the Large Value Map sample.

SmartGWT EE also provides wizards to pick any registered Hibernate entity and have it generate a SmartGWT DataSource that provides full read-write binding to that Hibernate entity. Just provide the generated DataSource to a SmartGWT EE grid or form with no other configuration, and you have a full CRUD UI: create, retrieve, update, and delete Hibernate-managed entities. You can do the same by pointing directly to a database table and immediately get full read-write binding. In both cases you can easily add business logic that runs before or after the Hibernate or SQL binding, which can modify the request before it executes, modify the output, or take any other action.

There is also a "batch" version of the binding tool that allows you to generate datasources for as many tables or domain classes you have in a single step. This is suitable for existing applications that have a large number of tables / beans and want to migrate to a an Ajax based rich UI.

Having gained a deeper understanding of SmartGWT EE, I will go as far as saying that, in my opinion, the functionality that SmartGWT EE provides makes it the most comprehensive and sophisticated solution for building rich enterprise UI applications with a Java backend - not just compared to other web based RIA technologies, but even compared to client-server Swing applications. I believe that productivity gains of SmartGWT EE are so high that it can cut down several man months of work down to weeks or even days, and thousands of lines of code down to hundreds.

Are they any features you use fairly extensively in your enterprise application that are not covered by SmartGWT EE? Or what other features would you like to see in SmartGWT EE? I personally can't think of too many but the one that comes to mind is adding support for Google App Engine (GAE) persistence as a SmartGWT EE DataSource connector. Thanks for reading!

A Look Back At...

evans — Sun, 5 Jul 2009 07:13:17 -0400

It has been a very busy week for me - working on new personal projects, moving office to a shared office space, planning my trip to Spain and a few other personal stuff.

In fact, here's a few of the things that have been keeping me very occupied for the last two weeks.

Twitter: I have been (still am...) working on a Twitter App in the evenings after work. I hope to finish it soon and post the details and create a website for it, until then I'm not prepared to divulge the details here, sorry.

Negotiating deals with some of our clients last week... it's taxing, you know!

Office move: We recently moved to a shared open-plan office with another company. This is all in a positive effort to cut cost and save jobs too - which also saw 2 staff members now work from home. What makes this arrangement even better is that all our email is managed by Google on their Google Apps platform. We have saved a ton on software, hardware and support cost for our email systems. You should also consider using Google Apps if it's an option. Not only does it save you cost on hardware and support, it also makes accessing, backup and management a lot easier.

I have also been working on my planned trip to Spain later this month to (hopefully) sign off the final stage of the project we have been working on.

Finally, I still have a few of my own personal stuff that have also been keeping me very busy. One of which I've briefly mentioned above.

So, there you have it!

GrifGain Training - Amsterdam and New York

Nikita Ivanov — Sun, 5 Jul 2009 01:36:33 -0400

GridGain will conduct 3-day advance public training in 2009:

Amsterdam, October 20-22 http://gridgain-ams.eventbrite.com
New York, November 10-12 http://gridgain-nyc.eventbrite.com

This training provides full in-depth learning of all features in GridGain. Beyond standard features and use cases, this 3-day course goes deep in complex scenarios of homogeneous and heterogeneous environments, SPI development, cloud environment and advanced security, custom topology resolution, and many other advanced topics.

This is another perfect opportunity to learn about see some of the new features that are coming in GridGain 3.0.

Hope to see you there!

Generating A Grails App Using GRAG

Mark Fortner — Sat, 4 Jul 2009 14:50:02 -0400

I recently needed to reverse engineer an application and thought I'd give GRAG another try. My first whack at generating a web app resulted in several hours of trying to make sense of the user interface and after not using GRAG for a while, I found myself making the same mistakes I made last time.

In order to generate a web application you need to:

Define a database connection.
Reverse engineer the entities (domain classes) from the database tables.
Generate the application.

The first and third steps are pretty self evident, but it's not evident that in order to reverse engineer the entities you need to select Add > Entity.

By default, GRAG does not generate the Controllers for you. However, you can do this by adding your own template to GRAG's templates/grails1/templates/model directory. In my case I added the simple file shown below to generate Controllers.

#foreach ($entity in $entities)
////File: ./grails-app/controllers/${entity.Name}Controller.groovy

/**
* The ${entity.Name} Controller.
*
* @author $config.authorText $config.companyText
* @version $Revision: $, $Date: 2006/07/07 20:04:13 $
*
*
*/
class ${entity.Name}Controller {
def scaffold = ${entity.Name};
}

#end

In my previous project, the schema did not make use of sequences, so the code generation was rather straightforward. However, while generating the code with 1.0 version of GRAG, it created code that grails wouldn't compile. It turned out that the 'sequence' keyword had to be surrounded by quotes and this wasn't the case with the code that it generated.

I tried downloading the latest version of the Entities.vsl template, but this was incompatible with the 1.0 release, and ended up generating code that wouldn't compile. I downloaded the code from SourceForge and thought I'd try the latest (and as yet unreleased version of GRAG). This was a particularly interesting experience, since I don't really use maven. It gave me the chance to try out Maven on Ubuntu with the latest version of NetBeans.

Ubuntu has this nice feature that if you type in the name of a command and if the binary is not available, it will give you the apt-get command necessary to fetch and install the application you want. So if you type in "mvn", it tells you to run "sudo apt-get install maven2". Once it was installed, you simply type "mvn assembly:assembly" and Maven creates a distribution of grag for you -- sweet!

After building GRAG 1.1 I was able to successfully generate my application, all of the code compiled and I was able to run it without any problems. Can't wait for the official 1.1 release!

GRAG WishList
During the course of my project, I noticed a number of a little things that would have made the experience nicer.

Support for controller generation: although it generates Entities pretty well, GRAG won't automatically generate the controllers for you as well. You could do a "grails generate-all" but then it would also generate the user interface views, and initially when developers are working on a project, they're loath to lock-down the user interface, especially if the domain objects are going to be changing pretty frequently.
Support for packages: It would be nice to be able to specify the package to be used for the domain objects, and have GRAG automatically generate the appropriate directories.
Clearer User Interface: It would be useful if the File menu had two additional menu items -- "Generate > From Database" and "Generate > From Model. The "Generate > From Database" menu item would pull up a simple dialog that allowed you to select a database connection (or create a new one), select the tables that you want to generate, and then generate the application. The "Generate > From Model" menu item would let you select the model and generate the appropriate classes.
Import database connection information: It would be nice to be able to import the database connection information directly from a Tomcat server.xml file.
Clearer Help pages: The help pages that you see through the GRAG Help > Content menu item have some truly painful background colors that make the help pages hard to read.

Facing the wall of closure Java (difficult) adoption

Dominique De Vito — Sat, 4 Jul 2009 11:47:33 -0400

Reading JavaOne'2008 reviews (yes, 2008, I have started to write first versions of this post mid-2008), I have learnt closures may be not adopted for JDK 7. New closure syntax reduces 'boilerplate' code, but then, the Java syntax becomes more complex. And another layer of complexity is added when generics are involved. Are the closures a bonanza ? Well, not that much as many wonders if the benefits really counterbalance the added syntax complexity. This poll result says nearly 40% of Java developers don't want closure adoption! So, it looks like closure feature is hitting a wall for its adoption.

IMHO, one way to lower the cost paid by users for closure introduction is to adopt type inference. Then, developers would write less type information (relying more on the compiler to do the job), and syntax will be simpler. The problem is: adopting closures is one step, adopting type inference is another step, and adopting both, as the same time, while it would alleviate the closure burden, could be too much enough for some developers. That's why closures may not be adopted within Java as we know currently this language; in other words, if closures and type inference were widely introduced and used into Java, one would not call this language Java again, but would be keen to use another name to make the day! Well, introducing those 2 features is just like moving from Java to C#'s last version, or even, to F# !

I have written in a previous post, entitled Symbiotic technologies, that technologies live in an ecosystem too. This post gave a first example about grid technology and virtualisation, detailing two main reasons why grid technology needs virtualisation. Today, I think type inference and closures are another examples of symbiotic technologies, i.e. closures need type inference to achieve full power and more use. Don't get me wrong: closures could play without type inference, but IMHO, it would be harder!

Java closure proposals come at a price! Closure are first functions. And, then, 2 (BGGA and FCM) of 3 most known closure proposals (the third one, here, is CICE) lead to treat functions as (new) first-class citizens (according to functional programming) that could be, for example, used as a method argument. Those 2 proposals introduce a special new notation for function signature; read Understanding the closures debate for details. This article gives the function type {T => void} as an example for BGGA, and the corresponding notation #(void(T)) for FCM.

Those notations create a break with the legacy method signature: methods, which are roughly functions associated with a class, still are associated with the legacy notation, while newcomers, that are, functions, are associated with a new shorter notation that carries equivalent information! So, here, closures come as the price of simplicity (while not minimizing the number of language concepts following the Occam's razor). The other proposal, CICE, does not give the same place to functions, and closure definition looks like concise anonymous class definition. But CICE proposal has drawbacks too: the closure definitions are not so concise, that are, longer than with other proposals, and functional nature of closures is hidden behind anonymous class definitions.

So, with explicit (static) typing, the closure introduction faces a dilemma:
- if the legacy notation is reused, then closures appear to be heavy,
- if a new notation is defined, then the language gives the feel of a certain lack of coherence.

Closure and typing mechanisms do have relationships. The fact that 2 over 3 Java closure proposals introduce a new function signature notation is a clear hint that closure and typing are related. A second hint is given through languages already providing closures: PHP (5.3) and ML (and its derived childs). PHP offers closures and is a dynamic language. Here is a simple closure example from What's new in PHP V5.3, Part 2: Closures and lambda functions:

$string = "Hello World!";
$closure = function() use ($string) { echo $string; };

$closure();

Output:
Hello World!

And here is a closure returned by a function (that example from wikipedia):

function getAdder($x)
{
    return function ($y) use ($x) {
        return $x + $y;
    };
}
 
$adder = getAdder(8);
echo $adder(2); // prints "10"

ML also provides closures and has a strong static typing through type inference. Here is a simple closure example from What is functional programming? in OCaml (OCaml is derived from ML, and has been cloned by Microsoft into F# as said before) :

# let multiply n list =
  let f x =
    n * x
  in
  List.map f list
  ;;
val multiply : int -> int list -> int list = <fun>

This multiply() function takes any list of integers and multiply each element by an arbitrary value n.

The function map() is here a function of the module 'List', It illustrates too how OCaml/F# deal more easily than Java with generics due to type inference. map() takes a function as argument, applies it to each element of an input list and returns a list of results. The map() function is a well-known higher-order function. This function is typed in OCaml/F#, and defined, as below. While translating type expression into Java, this function might be typed as "(A->B) -> List<A> -> List<B>". This function map() is defined through pattern matching (through match/with constructor):
* while taking an empty list [] as input, the result is also an empty list [].
* if the input value is the list hd::tl (head=hd and tail=tl), the function f() is applied on the head (i.e. "f hd"), and recursively called on the remaining elements of the tail (i.e. "map f tl").

# let rec map f l =
   match l with
     [] -> []
   | hd :: tl -> f hd :: map f tl;;
val map : ('a -> 'b) -> 'a list -> 'b list = <fun>

So, the OCaml/F# compiler has inferred that this map() function could be apply to any kind of list "l" and then, this argument is typed as " 'a list " (this notation is similar to List<A> that is more familiar to Java programmers). This is quite different than Java as Java programmers needs to make themselves explicit the generics use, and to type them.

Here is another simple use of this function map():

# let square x = string_of_int (x*x) ;;
val square : int -> string = <fun>
# map square [1; 2; 3; 4] ;;
- : string list = ["1"; "4"; "9"; "16"]

From the typing point of view, dynamic languages and languages with type inference share similar traits: no type is given while programming. They are more typeless than Java. And these languages of those families do provide closures, while Java does not.

So, closure and typing mechanisms do have relationships!

OK, let's go back to Java evolution. This leads to questions:
(1) what JDK 7 is going to bring for paving the way of closure introduction ?
(2) what could be Java evolution for closure introduction ?

(1) Coming JDK 7 would not bring some type inference, but notation shortcuts. JDK 7 does not aim to introduce closures. OK. A question remains: what could be JDK 7 improvements for paving the way of closure introduction ?

Project coin (announced here) is aimed "to determine what set of small language changes should be added to JDK 7". Joe Darcy talked about it during JavaOne'2009: see Small Language Changes in JDK Release 7: Project Coin. Among the features that we might see in JDK 7 is the diamond operator that would enable to construct more easily objects involving generics (Map<String, List> anagrams = new HashMap<>();). This diamond operator provides a simplification of the right-hand side (RHS) part of the construction instruction. One alternative is to simplify the left-hand side (LHS) and I have written about it in my post Next JDK wishlist-1: simplifying variable definition (var anagrams = new HashMap<String, List>();).

Putting the accent on the LHS or the RHS is exactly not the same thing. The RHS simplification (Map<String, List> anagrams = new HashMap<>();). is a shortcut and that's all. But, while both simplifications are related to notation shortcuts, the choice of the LHS leads better IMHO to type inference: while the first example above (var anagrams = new HashMap<String, List>();) is a LHS shortcut, others LHS simplification could put inference on the table, like, for example, "var l = 1L;" to define a 'long' value.

The LHS simplification seen above is a bit similar to the local type inference of Scala. The page A Tour of Scala: Local Type Inference says: "It is, for instance, often not necessary in Scala to specify the type of a variable, since the compiler can deduce the type from the initialization expression of the variable". Here is the given Scala example:

object InferenceTest1 extends Application {
  val x = 1 + 2 * 3         // the type of x is Int
  val y = x.toString()      // the type of y is String
  def succ(x: Int) = x + 1  // method succ returns Int values
}

The Scala type inference falls quite a bit short of the type inference mechanisms available in other languages, such as Haskell and ML (and its derived languages, like OCaml or F#), provides more a local inference, but it is quite useful too. The LHS simplification could be seen as an optional static typing, as type inference could alleviate the programming burden while a static typing is still possible.

But let's go back to Java.

JDK 7 improvements are not for paving the way of closure introduction; and particularly, no type inference is planned to do so.

(2) What could be another Java evolution for closure introduction ? Closures have been abandoned for JDK 7 as no proposal (BGGA, CICE and FCM - read Understanding the closures debate for details) provided unanimity, so let's move a step back, let's take a look at what's going on for other languages.

Let's take a look at C# closures. According to "Functional Programming in C# 3.0 using Lambda Expression" Part 1 and Part 2, it looks like one idea behind BGGA and FCM closure proposals is somewhat similar to the delegate concept of C#: the new function notation for BGGA, and the corresponding one for FCM, is like the delegate notation in C#. Here is an example:

// Java-BGGA
{Integer => void} print = { Integer arg => System.out.println(arg); }; 

// Java-FCM
#(void(Integer)) print = #(Integer arg) { System.out.println(arg); }; 

// C# 2.0
delegate void print(int x); 
PrintFunc mf = delegate(int x) { Console.WriteLine(x); };

So, closure comparison is interesting to look at.

And surprise, C# 3.0 has introduced some dose of type inference through the feature 'lambda expression'. So, C# 3.0 enables to use lambda expressions written in place of a delegate instance.

delegate int MathFunc(int x); // delegate type

// C# 2.0
MathFunc mf = delegate(int x) { return x * x; }; // anonymous method

// C# 3.0
MathFunc mf = x => return x * x; // lambda expression in place of delegate instance

And a lambda expression could be given as argument when a delegate type is the argument type:

customers.Where(c => c.City == "London");

The page Lambda Expressions (C# Programming Guide) precises the underlined typing mechanism: "When writing lambdas, you often do not have to specify a type for the input parameters because the compiler can infer the type based on the lambda body, the underlying delegate type, and other factors as described in the C# 3.0 Language Specification". [...]
"The general rules for lambdas are as follows:
- The lambda must contain the same number of parameters as the delegate type.
- Each input parameter in the lambda must be implicitly convertible to its corresponding delegate parameter.
- The return value of the lambda (if any) must be implicitly convertible to the delegate's return type".

I really like the way C# uses type inference, without sacrificing static typing.

Java closure proposals are not associated with type inference. Here are some details from FCM v0.5 - First Class Methods (FCM closure proposal): "The Comparator interface is the standard mechanism in Java to provide the code needed to sort lists. Here is a Comparator that sorts by length of String:

  List list = ...
  Collections.sort(list, new Comparator() {
    public int compare(String str1, String str2) {
      return str1.length() - str2.length();
    }
  });

With the changes in this proposal, the code could be written as follows:

  List list = ...
  Collections.sort(list, #(String str1, String str2) {
    return str1.length() - str2.length();
  });

A FCM with type inference would lead to a more concise notation:

  List list = ...
  Collections.sort(list, (str1, str2) { 
    return str1.length() - str2.length();
  });

Or using the BGGA notation, I rather prefer:

  List list = ...
  Collections.sort(list, { str1, str2 =>
    return str1.length() - str2.length();
  });

While such a shorter typeless notation, closures appear quite more appealing, and one could be more confident that Java will stay attractive according to programmers' needs.

So, I see 2 ways for Java.

(2.a) Closures could be introduced with type inference through lambda expressions, but without introducing functions (equivalent to delegates). It would be a matter of type matching (following the C# matching algorithm). Without functions, closures would be typed as an interface, similarly to Next JDK wishlist-3: a first step towards closure into Java. To say things differently, methods that would like to take a closure as argument would have to type this argument with an interface, and the lambda expression representing a closure will be boxed into that interface.

(2.b) Another step for closure support could be named closures. (2.a) provides only one way to name a closure: to box it into an interface. Some current closure proposals give another way through introducing a function type. I wonder about the need of such a new type if closures are implicitly typed, or if the compiler just types lately such closures. Following the idea Next JDK wishlist-1: simplifying variable definition, let's imagine the following:

var plus = { x1, x2 => x1 + x2 };

While using such simplified variable definition, the first idea is to type the RHS and to associate this type with the variable. OK, I just like an early typing, but late typing could make the day for some cases; while dealing with closures, the compiler could try to type them according to their uses. In the current case, the plus variable would not be typed when defined, but when used as a method call argument; the compiler would try to type the plus closure while trying to match it with the corresponding argument type of the method.

So, what about closures in Java ? Again, IMHO, closure and typing mechanisms do have relationships. Introducing closures, following one of the current closure proposals, looks like a hard problem to solve, without considering some dose of type inference. I think one way to solve a problem, if a solution is hard to find, is to look for a solution into a bigger solution space. Closure proposals are one solution space, and closure+type inference proposals are a bigger solution space, I am more in favor with, just see one of my post Next JDK wishlist-1: simplifying variable definition.

Well, I am not happy with the way Java is evolving, and while comparing, C# looks like more and more appealing. IMHO, it looks like Java needs not a light treatment for closure introduction, but a shock treatment to help the patient not to die, not to be the next Cobol.

Dynamic languages are more and more widely adopted, just think about PHP. Those languages promote closure use and a typeless programming. While Java is a static language, I don't think Java could avoid for a long time to include some functional traits, and some dose of type inference.

Well, I have written Thoughts about Java, C# future and OCaml (?) relationships, suggesting that Java and C# were evolving towards ML programming model, that is, to include some dose of functional features and type inference. I have written that post in July 2005, 4 years ago! C# has followed that way. Java promoters are still reluctant, but let's see where Java goes.

The quest for a portal web framework is over and the winner is: Spring Portlet MVC

Jakub Holý (Holy) — Sat, 4 Jul 2009 03:36:36 -0400

For a long time I've been looking for a web framework that would ease the development of web UI in portlets. Pure JSP is too old-fashioned and the abstraction it provides is just too low-level. There are many good web frameworks for standard web applications (JSF/Seam, GWT, Struts 2, Wicket, you name it...) but if they include portlet support than only as an after-thought and it's usually far behind the quality and features of the standard web framework. Nobody was able to recommend me a decent portlet web framework - until recently.

First I've learned about an upcoming book Portlets in Action by Ashish Sarin, which teaches not only Portlets 2.0 (JSR 286) but also other must-haves for a real world development like a portlet web framework and Ajax (DWR in this case). You've surely already guessed that Ashish uses Spring Portlet MVC, which indicates that it must be indeed good.

Than I've been surprised to learn that my good and trustworthy collegue, Vlado, is using Spring Portlet MVC on his project. He had but positive words about the framework: "It's excellent, I wouldn't make portlets with anything else. It's enough lightweight, it helps where it should and doesn't limit you anyhow."

The only issue is that the current stable release doesn't support JSR286 yet (events, resource serving...). Fortunately the upcoming release of Spring 3.0 will support it. Spring 3.0 M3 have been released in May 2009 (more about Portlet 2.0 support on M2 release page), RC1 should have been released in June. You can learn about details in the corresponding Jira issue.

Resources

Liferay wiki:

Spring-Hibernate-DWR - Integrating Spring MVC Portlet 3.0 M2, Hibernate 3.3.1 GA, DWR 3 RC1 and Liferay 5.2.2
Sample Spring Portlet

Groovy Coffe Cup - take two

Andres Almiray — Sat, 4 Jul 2009 03:19:52 -0400

It's been quite a while since this blog featured information on GraphicsBuilder, I'm pleased to announce that the builder is not dead, it actually has been rebooted with a new name, GfxBuilder, its sources can now be found under the Griffon umbrella project. The last example shown on this blog was GraphicsBuilder's take on a JavaFX based example: a Coffee Cup with Groovy. As stated on that previous entry there were some kinks to be found on the Groovy version, radial gradients not being able to warp according to its containing shape just to name one. I'm happy to say that no longer is true! here is the updated code with pictures, the first pic corresponds to the older version, the second pic is the newer version.

OLD

NEW

Notice the slight differences in shadows and colors?

antialias true
  background("black")
  
  group(id: "plategroup", borderColor: "none") {
    ellipse(cx: 0, cy: 10, rx: 160, ry: 50, f: gfx.color("darkGray").brighter())
    ellipse(cx: 0, cy:  3, rx: 170, ry: 50, f: gfx.color("lavender"))

ellipse(cx: 0, cy:  0, rx: 170, ry: 50, opacity: 0.5) {
      radialGradient(fy: 100, r: 270) {
        stop(s: 0.0f, c: color("whiteSmoke"))
        stop(s: 0.5f, c: color("lightGray"))
        stop(s: 1.0f, c: color("darkGray"))
      }
    }
    ellipse(cx: 0, cy: 5, rx: 90, ry: 22, opacity: 0.8) {
      radialGradient(r: 180) {
        stop(s: 0.0f, c: color("black"))
        stop(s: 0.4f, c: color("lightGray"))
        stop(s: 1.0f, c: color("white").darker())
      }
    }
    transforms {
      translate(x: 100, y: 120)
    }
  }
  
  group(id: "cupgroup", borderColor: "none") {
    subtract {
      circle(cx: 100, cy: 100, r: 50)
      rect(x: 25, y: 50, w: 150, h: 50)
      radialGradient(r: 100) {
        stop(s: 0.0f, c: color("whiteSmoke"))
        stop(s: 1.0f, c: color("whiteSmoke").darker())
      }
    }
    ellipse(cx: 100, cy: 100, rx: 50, ry: 8, f: color('white'))
    ellipse(cx: 100, cy: 100, rx: 48, ry: 7) {  
      linearGradient(y2: 1){  
        stop(s: 0.0f, c: color("whiteSmoke"))
        stop(s: 1.0f, c: color("whiteSmoke").darker()) 
      }  
    }
    intersect(f: color('darkOrange').darker().darker()) {  
      ellipse(cx: 100, cy: 100, rx: 48, ry: 7)  
      ellipse(cx: 100, cy: 102, rx: 46, ry: 6)  
    }
    transforms {
      scale(x: 1.7, y: 1.9)
      translate(x: -20, y: -53)
    } 
  }

The code is a bit shorter this time, note that there is no need for a global translate transform on the top level group, though scaling and translating the cup is a bit tricky, maybe if the cup was drawn initially at the world origin (like the plate is) but the intent was to follow the JavaFX example as closely as possible. A fine addition to groups is the opacity: property, it is applied to all members of the group, in this case it is used to apply a sense of 3D to the plate without actually looking harsh, kind of like a soft shadow so to speak. More news to follow soon, they're bound to make you feel animated about Groovy

Keep on Groovying!

Twitter Posts for Jul 2, 2009 - My tweets, REST tweets, Groovytweets

Solomon Duskis — Fri, 3 Jul 2009 08:54:52 -0400

sduskis - Twitter Search

@sduskis (Solomon Duskis): RT @bderidder: "the only good Enterprise Service Bus (ESB) is a dead ESB" glad there are still sane people around (http://bit.ly/KgbNA) (Fri 07:52 AM)

@sduskis (Solomon Duskis): HAML looks interesting (Ruby HTML DOM creator). Is there something like that for #groovy #grails? (Fri 07:50 AM)

@sduskis (Solomon Duskis): @lpolycarpou JAX-RS as MVC framework... You're not the first. There are some limitations, like request attribute/session management. (Fri 07:33 AM)

@sduskis (Solomon Duskis): @jsbournival try javax.ws.rs.core.MediaType. It has a whole bunch of mime-type constants. (Thu 07:20 PM)

@groovytweets (groovytweets): RT @sduskis: Simple Zip utility writen in #groovy: http://bit.ly/J7D04 (Thu 03:56 PM)

@grailspodcast (grailspodcast): RT @sduskis: Simple Zip utility writen in #groovy: http://bit.ly/J7D04 (Thu 03:55 PM)

@sduskis (Solomon Duskis): Simple Zip utility writen in #groovy: http://bit.ly/J7D04 (Thu 03:20 PM)

@sduskis (Solomon Duskis): Simple zip file written in #groovy: http://bit.ly/J7D04 (Thu 03:19 PM)

@sduskis (Solomon Duskis): Blog of Twitter posts I care about for 7/1/09 - http://bit.ly/d7m7A. I used RSS feeds and 90 lines of #Groovy. (Thu 09:50 AM)

Sungard OR #WHN - Twitter Search

@ChrisShain (Chris Shain): Besides virtualized infrastructure, what support does your cloud platform deliver for the developer? Or is it just virtual datacenter? #whn (Thu 10:41 PM)

@imalba (Issary Alba): Got the internship with SunGard!!!!! Customer Analysis in the Brass/Liquidity Services Group. (Thu 08:30 PM)

@john_avery (John Avery): DTCC role(s) in CCP Proposals - http://tinyurl.com/kt2vgc - #whn (Thu 04:35 PM)

@rfpconnect (RFPConnect): SunGard's Ambit Refines Data And Reporting Of Surrenda-Link http://bit.ly/IgHPj (Thu 08:37 AM)

groovytweets ::: latest tweets

@berndschiffer (Bernd Schiffer): Argh, http://grails.org down #ppfgb #grails (Fri 06:52 AM)

@vaclav_pech (vaclav_pech): @groovymag Sure, very well written. Thank you and Jorge. Much appreciated. (Fri 06:52 AM)

@groovymag (groovymag): July 2009 GroovyMag is available. Makes great holiday weekend reading for you US folks http://groovymag.com/latest (Fri 06:50 AM)

@snaglepus (Robbie James): @wangjammer5 can't you just: def index = { redirect(action: list, params: params, flash:flash) }// if you need to? #grails (Fri 06:19 AM)

@wangjammer5 (Marc Palmer): Avoid this at all costs in Grails: def index = { redirect(action: list, params: params) } // you lose anything in flash scope. (Fri 06:00 AM)

@wangjammer5 (Marc Palmer): Thinking I need to find a way to have nav items from multiple controllers appear under same main heading in nav plugin. Tricky (Fri 05:54 AM)

@wangjammer5 (Marc Palmer): LMAO oh how disgusting of me. I just thought "Wouldn't it be GREAT if there was a groovy impl written in Javascript". Client side groovy. (Fri 05:29 AM)

@berndschiffer (Bernd Schiffer): Versuche, #grails auf #hudson via #ant und #ivy zum Laufen zu bekommen. Kennt da jemand gute Online-Referenz zu? #ppfgb (Fri 05:12 AM)

@wangjammer5 (Marc Palmer): @wmacgyver Yep. We all need to throw the Grails dev team a bone. The fact is you only hit the problems later. (Fri 05:12 AM)

@berndschiffer (Bernd Schiffer): Erfolgreich von Grails 1.1-RC1 auf Grails 1.1.1 geupgradet. Lokal. Webtests zeigten Differenzen, konnte aber schnell gefixt werden. #ppfgb (Fri 05:11 AM)

@wmacgyver (Mac): @wangjammer5 agreed, all the people whined about grails 1.1.1's current bugs on the list, they better step up, try 1.2M1 and AT LEAST report (Fri 05:02 AM)

@wangjammer5 (Marc Palmer): New blog post about why Grails users need to download 1.2M1 now and use it. http://bit.ly/TWpJJ (Fri 04:57 AM)

@vaclav_pech (vaclav_pech): The recent @groovymag covers GParallelizer. Check it out! (Fri 03:07 AM)

@hansamann (Sven Haiges): thx @ecspike for helping me with google charting. Updated groovytweets popularity chart: http://bit.ly/QSPsa (Fri 02:37 AM)

@berndschiffer (Bernd Schiffer): One might want to respond to that (@graemerocher? @mittie?) : via @cretzel: Blog about #java, #scala, #groovy benchmark http://trunc.it/p325 (Fri 02:23 AM)

@hansamann (Sven Haiges): Done quick-reading Dave Klein's GQuick: 196 pages, great for devs beginning with Grails and looking for a hands-on guide (Fri 02:04 AM)

@wmacgyver (Mac): @vaclav_pech should really bring the excellent google collections into groovy core and encourage immutable usage via mapmaker (Fri 02:02 AM)

@russmiles (Russ Miles): Wishing I could figure out a way to scope Grails plugin dependencies like you can in Maven. Want to call a test dependency what it is! (Fri 01:48 AM)

@wmacgyver (Mac): @vaclav_pech so basically you are setting up agent as actor that accept a groovy closure? (Fri 01:38 AM)

@vaclav_pech (vaclav_pech): First thoughts on the Clojure-inspired Agents in GParallelizer, please comment - http://code.google.com/p/gparallelizer/wiki/SafeVariables (Fri 01:34 AM)

@vaclav_pech (vaclav_pech): Did anyone try the IntelliJ IDEA Clojure plugin? It works fine for me, but I've just made my first small step into the language. (Fri 12:46 AM)

@hansamann (Sven Haiges): Beginning to read 'Grails - A Quick-Start Guide' by Dave Klein. Promises to be a great book. (Fri 12:45 AM)

@hansamann (Sven Haiges): groovytweets now has a twitter user popularity chart, pls retweet. http://bit.ly/1dE6V (Thu 11:43 PM)

@seantindale (Sean Tindale): GraniteDS Flex Plugin for #Grails . Holy cow! I wish this was around 1 year ago. Very temped to redo my interface (Thu 10:36 PM)

@daveklein (daveklein): Grails: A Quick-Start Guide Beta 4, containing all 12 chapters, is available! You can find it at http://tinyurl.com/md646f #grails (Thu 10:01 PM)

@shemnon (Danno Ferrin): @spidie We haven't truly arrived until we see a "#Griffon is teh suck" post on a blog. That post was genuine concern, so not quite. (Thu 09:36 PM)

@GroovyJobs (Groovy Jobs): Blog News : Groovy Templating Follow-Up http://minurl.org/kVU1 (Thu 09:00 PM)

@spidie (Steve Dalton): I know that post to the #griffon list was a little dumb, but I really like seeing these posts and the awesome community responses. (Thu 08:35 PM)

@theaviary (Griffon Framework): blog post: "Griffon Action Patterns" http://tinyurl.com/krurrb by @joshareed discuss! (Thu 08:03 PM)

@joshareed (Josh Reed): Brought my blog back to life after a several month hiatus to talk about working with actions in #griffon: http://tinyurl.com/krurrb (Thu 07:54 PM)

@hansamann (Sven Haiges): Did you already click the groovytweets ad banner today? Wink. (Thu 06:45 PM)

@dima767 (Dmitriy Kopylenko): :@aalmiray Make that Groovy/Erlang/Haskell/Scala/Clojure/ObjC (iPhone) I wish. My wife is working tonight and I'm entertainin' daughter (Thu 06:08 PM)

@aalmiray (Andres Almiray): @dima767 that means you now have extra time to hack around some Groovy/Grails/Erlang/Haskell code, right? (Thu 06:03 PM)

@aalmiray (Andres Almiray): Griffon @ Silicon Valley Web JUG http://ff.im/-4JnCi (Thu 05:31 PM)

@hartsock (Shawn Hartsock): Well this sucks... I can't release the fixes for GRAILSPLUGINS-1181 and GRAILSPLUGINS-391 because of some strange SVN bug. (Thu 05:28 PM)

@ecspike (James Williams): just pushed #grails google-chart-plugin v0.5.1, thx to James Beamish-White for the patch #groovy (Thu 05:15 PM)

@wmacgyver (Mac): very close to abandoning #eclipse 3.5, the new UI for install/update plugin is unusable. checking to see if there is new update is a chore. (Thu 05:08 PM)

@lucastex (Lucas Teixeira): Love #groovy builders... (Thu 04:48 PM)

@hartsock (Shawn Hartsock): I remember now ... GRAILSPLUGINS-391 ... is a really sticky wicket. *grief* (Thu 04:42 PM)

@olabini (Ola Bini): Yay. Now have Reason and Cubase installed again. A gazillion plugins left, and then I can start making music again. (Thu 04:36 PM)

@bill_turner (Bill Turner): Just published the latest in the series of posts reviewing "Grails 1.1 Web Application Development". See http://ping.fm/gvhLA (Thu 04:05 PM)

@glaforge (Guillaume Laforge): Mes slides sur les DSLs en Groovy pour l'#usi2009 : http://tr.im/qFLm (Thu 03:55 PM)

@sduskis (Solomon Duskis): Simple Zip utility writen in #groovy: http://bit.ly/J7D04 (Thu 03:20 PM)

@groovytweets (groovytweets): #gae is up again, so groovytweets will be up too an tracking your groovy tweets (Thu 03:19 PM)

@mbrevoort (Mike Brevoort): damn I wish I had the profiler in Flex Builder Professional right now (Thu 02:58 PM)

@marceloverdijk (Marcel Overdijk): @lucastex Yes we are using #NetBeans 6.7 to develop #Grails applications. I really like it. (Thu 02:38 PM)

@hartsock (Shawn Hartsock): I just got an unexpected day off... what am I going to do with it? I know... fix the bugs in my neglected plugin. (Thu 09:02 AM)

@spidie (Steve Dalton): Retweeting @paulk_asert: The latest version of my Groovy Tutorial Slides updated for #citcon are on SlideShare: http://bit.ly/1LPVI (Thu 09:02 AM)

@spidie (Steve Dalton): @paulk_asert slide 5 blew me away on the #grails job ads - is that global or just US? (Thu 08:48 AM)

null @spidie (Steve Dalton): @mgkimsal - thanks for including our user group in @groovymag... we now feel complete! (Thu 08:43 AM)

Java REST - Twitter Search

@blogger_adrian (Adrian Hamilton): Update on blog sidebar not displaying: Not a Google glitch, some java script not loading that was effecting the rest of the page - removed. (Fri 03:58 AM)

@aMmadz (Ammadz Faiz): updating #iPhoto, #iWork, #Java update and #Aperture.. the rest can wait.. (Fri 01:22 AM)

@seantheflexguy (Sean Moore): client call in 15 min.. then AIR/Java (BlazeDS enabled) dev for the rest of the day. thinking about doing more book reviews but cant decide. (Thu 12:44 PM)

@maxgaldinus (maxgaldinus): Criando um serviço REST e chamando Java no OSB: O Oracle Service Bus, ou OSB, é a ferramenta que provê a funcion.. http://bit.ly/3BIJh (Thu 11:42 AM)

@JavaPuppy (Happy Keller): Spent the night hacking & coughing...fever got to 102+...fever's gone; still not feeling too good...Dr. Java & Nurse Mocha prescribe rest... (Thu 10:01 AM)

RESTEasy OR RESTlet OR JAX-RS - Twitter Search

@sduskis (Solomon Duskis): @lpolycarpou JAX-RS as MVC framework... You're not the first. There are some limitations, like request attribute/session management. (Fri 07:33 AM)

@NunoCardoso (Nuno Cardoso): @ruidlopes Estás a usar o restlet 2.0? tenho um NoClassDefFoundError: org/restlet/Redirector, parece que no 2.0 está numa subdir routing. (Fri 07:16 AM)

@ruidlopes (Rui Lopes): @NunoCardoso yep, fiz um serviço inteiro em restlet: html, json e rdf, tudo sobre http. tb há builders: http://whit.me/axdtZ3 (Fri 05:45 AM)

@lpolycarpou (Louis Polycarpou): Researching JAX-RS implementations as a potential MVC framework... (Fri 05:28 AM)

@alartin (Sean Wu): I programmatically tweeted with the RESTEasy Client at Fri Jul 03 13:51:36 CST 2009 (Fri 12:51 AM)

@jsbournival (jsbournival): searching in vain for jax-rs mime-type constant ... have to define them myself ... but I do not trust myself. (Thu 02:16 PM)

I created this entry with Groovy and RSS feeds. Do you want to know more? Leave a comment