Internna - Geared towards Open Source

My TODO list for 2010

2009-12-12T03:00:00.001-08:00

It's that time of the year again! A lot of good wishes most of which won't ever see the light of day, of course :-) But no more introduction, here's my task list for next year:

Spring 3.0
IWebMvc2 is rapidly approaching a final release (I'm two bugs short). I'm already thinking in features for 3.0 and the new version of Spring tops the list. I'm specially interested in the new @REST/MVC support as I want to test an AJAX approach based on Jackson views.
JEE6
Continuing the trend IWebMvc3 will be fully JEE6 compliant. The interesting parts of the specification are the new dependency injection JSR, the new validation model, web fragments, the web profile and (why not?) asynchronous servlets.
Maven 3 / Spring Roo
What am I looking for actually? Scaffolding? No, not really. I'm more in the search for a project management tool that works at source level, integrates well with an IDE/third party tools (Hudson, Sonar) and saves me time applying all those things common to any web application like security, logging, testing, validation, you name it.
Open Source work
I'm not going to abandon IWebMvc/IWebJTracker development, of course. But in addition I want to extend my commitment with Gmaps4JSF (you like MapSicle?) I may even join Hazem in his new adventure
Google projects
Probably the source of most interesting news this year has been hands down, Google. I'm going to closely follow Guava, GAE, Closure, Chrome and may be, just may be, GWT.
HTML 5
I'm not sure if next year will complete the transition but obviously you can't miss this train.
OSGi
I want to test Glassfish v3 OSGi capacilities. And Spring products as well. A project that has always appealed to me has been classworlds...may this is the time?

So what is yours?

FishCAT testing for v3

2009-12-08T01:27:00.000-08:00

Last week the latest installation of the FishCAT program came to an end. FishCAT is the GlassFish Community Acceptance Testing program, that is, a community program run by Sun to QA GF (in this case v3) that gets participants from around the globe ().

I like to join it each time for several selfish reasons. After all, Netbeans + Glassfish is my preferred development platform and if I'm going to use it extensively I want to ensure that it suits my needs. In addition, neither IWebMvc/IWebJTracker nor GMaps4JSF were working in GFv3 back at the start of the program. That, of course, forced me to use Tomcat as my main development server. Fortunately Glassfish shares code with Tomcat so having something working in the later means good news to solve the problem in the former.

The process is really simple, when you find an issue you post a message in the mailing list and after a preliminary revision you're asked to post a bug report in the tracker. Just this initial check was enough to fix the Gmasp4JSF issue (a bug with the application code that traversed the folder structure below /, a subtle difference with Tomcat which wouldn't complain and just set the path to /) so it's a crucial step. There's an obvious commitment with the project and an internal dev is immediately assigned to the issue and you can see steady progress right form the start.

Here's a brief list of pros:

The people at Sun top the list without doubt. I haven't ever seem a team of such positive and passionate folks. Special thanks go to Judy Tang and Jan Luehe who were always helpful!

The importance given to the bugs. FishCAT is not a PR project. Sun really wants external devs to participate and puts resources to fix the issues reported. Kudos to the company here. They really understand how to run this kind of activity.

They helped me as much as I helped them. Yes, I reported several nasty bugs in the deployment and web container components but in the process I got advices and could fix several hidden issues of my applications as well. It was a clear win-win situation for all of us.

GFv3 will be the first EE 6 implementation available and that's a feat worth some testing.

Tens of developers from countries as different as Germany, China, South Africa, USA or Spain to mention some

GMaps4JSF and IWebMVc will fully work in the final release of GFv3!

I have one con though:

For God's sake, please upgrade the network infrastructure! And that twentieth century issue tracker as well! Some days just posting a bug was such an exasperating task..

All in all, a very positive interaction indeed. I hope to see some of you next year!

IWebJTracker progress update

2009-11-27T04:26:00.000-08:00

It seems to me that as of lately I just post about IWebJTracker/IWebMvc2 progress. I guess that I don't have time for more...a pity. Nevertheless here goes another update.

Next IWebJTracker milestone will be mainly based around integration. The project more or less handles issues already but it needs to communicate better.

The first step in this path is providing friendly URLs. IWebJTracker has them now (for example, /project/IWEBJTRACKER will load the dashboard and automatically open the project). A bookmarking option has been also added (though I have to improve it...I'm not happy with the result yet)

The second step is RSS, my preferred way to get updates on things I'm interested. I've added support to the framework and now every action should be pusblished to a feed.

And the last step would be, something that can't be missed in an issue tracker, email support. I've added the Javamail connector but I haven't yet decided the interception points. Right now, IWebJTracker only emails the user to confirm the registration process. It's a matter of adding more templates.

But the user is not the only target and continuing with the Java & Open Source focus, the tracker can now get updates from the remote APIs of Hudson:

And Sonar (data extracted from Nemo):

Of course some other areas have received attention as well. For example, the My Projects tab now includes a timeline chart:

And..not really coding related...I've designed a logo for the project! I do not accept critics about this ;-)

I hope you like the changes. As always, comments and help are welcome!

Yet another...issue tracker

2009-11-02T00:00:00.000-08:00

I started the development of IWebJTracker because I needed to demonstrate the public and myself that IWebMvc was a good enough framework that simplified development of 2.0 applications. Application Lifecycle management has always been an area of interest for me so an issue tracker seemed like a good candidate to code.

The truth is that in the midtime some things have happened that affect the project (for example, Jira has a new version and price scheme and JetBrains has released a new product in this space, YouTrack). So the market situation is this:

There are very good commercial solutions (Jira, FogBuzz, YouTrack)
There are very good Open Source solutions (Trac, Bugzilla)

But, IMHO all that doesn't change anything. I still miss an open source bug tracking system written in Java and that deploys to Tomcat out-of-the-box. So that's why IWebJTracker may still make some sense to someone down the road. Even more so if Subversion and Maven are also their target.

But, make no mistake, all the above alternatives are better than IWebJTracker. Not only because they're more mature (remember this is a first milestone what I'm releasing today) but because they have a team of people (probably way better coders than I am) helping with the development. Remember that this is a one-man project coded during free hours. No more, no less.

If you still want to try it out, bear with:

The fact that this is not production ready
It has obvious flaws (no notification system yet, for example)

Last, I would like to publicly thank you the rest of the people that make possible IWebMvc first and IWebJTracker later: the DWR team, the dojo team, SpringSource, Scott Schiller, Alex Gorbatchev or Jordi Sellés among others.

The download is available at the project page. And more or less resembles like this:

As always feedback, opinion or help is appreciated. Look for me on the mailing list.

Jira 4 raises the bar...

2009-10-07T05:27:00.000-07:00

In case you've missed it, the announcement. Impressive, isn't it? Obviously I can't compete! A team of engineers and thirteen months of developement..starting with Jira 3. Admittedly, I'm a lonely developer, I've been working for three months during my free time and I started from scratch! Nonetheless, I won't despair...at least IWebJTracker will be fully Open Source and it doesn't look that bad actually (given that I'm not a designer, of course). Take a look at the main screen for an issue (as of now):

And somehow I've managed to keep things under control (which is always good if other developers decide to help):

I'm really looking forward to releasing a first milestone and see the acceptance it gets from the community!

The problem of Open Source

2009-09-22T09:50:00.000-07:00

I've just had a meeting. The topic of today was finding a way to replace a software tool in use in some random area of a client. It's a testing tool but they have tweaked it to become a robot, like say AutoIt. Not that I'm against of new uses for software but, really, using a testing application to create robots to manage windows created by your own code instead of using a batch process is a little bit over the top. But I digress as the problem, of course, is other.

The problem is money. Licenses in fact. The issue is they're paying some royalties to another company (one that develops and sells software) and they're uncomfortable with the situation. Nobody says it like that and so the official excuse is the programming language of the scripts, VBA. But nonetheless, it's obvious to everybody.

And so they've asked me if I knew of any Open Source library written in Java, free (as in beer) with a good community (support is crucial remember?) that could handle their use case. Right there I stopped paying attention. I have some wishes myself.

But, at least, I got something positive out of it. I got to think about why and/or how have we reached this situation? The outlook is indeed grim. Somehow nobody feels like paying for software anymore. Everybody expects to find some OSS project out there that resolves all kind of problems but, of course, just a minority of people (let alone enterprises!) consider donating code or contributing to any project. And worst, probably us (open source developers) have helped to create this kind of environment. Right now, Open Source and gratis are synonyms in the mind of many people. What was that about birds and beers? Heck, nobody really cares.

Even worse is the disgrace that plagues the OSS world: whining users. Because too soon free is not enough and people demand more and more and more. Bandwith, documentation, examples, a forum, mailing lists, developers to answer promptly their question, enhancements, side projects...you name it. Sorry, I forgot to mention, free again.

So our work and time is now expected to be altruist...and then cost us something in the process. But it never works the same the other way around. Sadly, it's sometimes becoming a burden. Too hefty.

A rhetorical question, when will people awake and realize this is unsustainable? I've notice a trend, each year less and less people choose Computer Science as their studies. Can't help but think that they are not that wrong.

They say generics are stupid...

2009-09-10T01:07:00.000-07:00

Who am I to blame? This how my class declaration ended up being:

public abstract class AbstractProjectManager
   <C extends ConnectionDetails, M extends Module<P, M> & DomainEntity,
   P extends Project<C, M>> implements ProjectManager<C, P> {
...
}

With other niceties such as:

public interface Module<P extends Project<?, C>, C extends Module> {
...
}

Now, I keep looking at them and thinking "if I have to do this there's something terribly wrong going with this design!" :-)

On the other hand no one seems to complain about the overall quality of the code...

So the development of IWebJtracker continues at a good pace

New Gmaps4JSF plug-in architecture

2009-09-05T01:46:00.000-07:00

Chances are that if you have ever needed to add some kind of geolocation to a "enterprise" application you have met GMaps4JSF. For those who haven't the name says it all really but, nonetheless, I will translate for the lazy, Google Maps for JSF, that is. There are other alternatives, and good ones, like say Richfaces but AFAIK this is the only one that works wirh JSF 1.1, 1.2 and 2.0, with or without AJAX, with or without Facelets and so on. Basically it works everywhere.

The library is pretty complete as it already supports the map component and several children like markers, information windows, event listeners, street views et al. But it didn't span beyond what Google offers. Till now I should say. The thing is a client asked (some time ago) to provide some map functionality that unfortunately wasn't covered by Gmaps4JSF. I tried a pure Javascript approach first but, obviously, the results were not elegant in an otherwise pure server side application. Then I tried patching the library. In the end I did the job but this solution had also many drawbacks, the main one being that future releases would be incompatible with the changes and would leave the client stuck with an old version and without access to bug fixes. This was unacceptable. So I asked Hazem Saleh, the author, about a third way, creating a plugin system that could allow me and others to create new functionality without touching the core. We quickly agreed of course :-)

Hands on with the task I devised a possible alternative. As Gmaps4JSF is Maven based it needed to be a new module. That was pretty clear from the start. I then tought about diving it even further and force the creation of new subprojects inside this module. Two problems remained, the first being the distribution (because I didn't want to require a new JAR download for each new plugin) and the second the integration with the core (because it should be seamless for the user).

The former issue was solved by using the Shade plugin. I tried the Assembly plugin before but felt short soon. Both Maven plugins allow the developer to group project artifacts and apply some rules in the process. The sahed plugin fitted better because it allow us to combine all JARs in a single one AND merge XML and text files to obtain a unique tag library as the result.

The later was solved by designing a very simple (we want other people to contribute!) plugin architecture in the core. Just one interface (three methods) is enough to determine how a plugin interacts with the rest of the environment. So to build a new plugin you just need to follow these steps:

Get the idea
My first two plugins were ported from the gmaps-utility-library project (drag zoom and tabbed max content). There are many other.
Create a Maven module
Inside the Gmaps4JSF use the maven archetype to create a new module under the plugins folder. Add it to the parent POM if so you desire.
Declare the attributes of your component
Just copy&paste one the available components and edit the attributes you need (for example, latitude and longitude).
Implement the Plugin interface
You have examples available so it should be pretty straightforward. You have access to the parent component (where your component is nested) and the map (both in JSF and Javascript).
Register the plugin
Just add one line (for each plugin) with the name of the implementation class to a plugins.txt file in your META-INF directory.
Create an example
Nothing sells an idea better. It's just a simple JSP page.

And that's all really. If you decide to contribute an addition to the project drop a line in the mailing list. There are many interesting extensions to the map API so now you have the opportunity to colaborate without the fear of having to understand the entrails of JSF or the code of Gmaps4JSF. And for the rest, enjoy the current work!

IWebMvc2 Final Release Candidate available

2009-08-26T01:33:00.000-07:00

So, I've finally sit down to fix all the issues in IE and added some features required by IWebJTracker (like built-in grid filters and order by). I've uploaded a version with all the patches. Quite improved IMHO. And faster but beware that miracles in IE are beyond my capabilities. As a side effect it also works in Opera 10 Beta 3 in my tests and that's good as well.

Not everything are good news though as I've introduced a (very visible) nasty bug that happens when the Locator tag file is compiled. It just happens once and it's resolved by hitting reload on the browser but the first impression (a Tomcat error page) is horrid, I know. Sigh..

From now on I'll try to devote more time to the issue tracker and less to the framework. Let's see how it turns out.

Enjoy!

IWebJTracker...a teaser

2009-08-18T12:04:00.000-07:00

Just some screenshots so you get a taste of the current state of IWebJTracker:

IWebJTracker is/will be the first application built using IWebMvc2. I hope it will become a full ALM solution but at least it will be a Java oriented issue (bug) tracker. Open source, of course :-)

Say it with me...GE-NE-RICS

2009-07-25T09:52:00.000-07:00

Sorry, I'm in a bad mood today. It must be an uphill battle I guess. I've seen people confused with generics (I'm talking about Java here). They seem to get the concept and can use generic collections pretty well. Once teached they happily write:

Set<Something> somethings = new HashSet<Something>();

And for some unforeseeable reason they're happy with themselfs and proud of using generics. Some of them even attempt to understand advanced concepts like erasure (a concept that shouldn't even exist by the way). And, in fact, they do. Now, that's the end of the story. A dead end indeed.

For the great majority generics are something, revolving collections (and comparators..or was that TOO advanced?), made by Sun so everybody can use them later in their applications. Nobody seems to go one step beyond and try to develop generic classes of their own. Go figure!

So say we are designing a client application that needs to connect to several types of servers. A downright mediocre architect would write:

public interface Server {
   Object openConnection(Object connectionDetails);
}

He will argue that the specific types are unknown at the moment. Utter crap, of course. While an old school, barely capable, one would instead put something like:

public interface Server {
   Connection openConnection(ConnectionDetails connectionDetails);
}

Better no doubt. But it suffers the same issue, namely downcasts. Downcasts are obviously not elegant but they also pinpoint problems and bad practices. Avoid like the plague.

Generics to the rescue. Yes, you can do better! Believe me! That's what generics are really for. Not for collections but for you! For your designs! Let's refactor that interface of us a little. What would we need? Well, we know that a connection to the server is needed and that the server implementation and hence its connection are only known by the subclass in particular. So a FTP client has to return a different connection object that a Subversion client. Fine. Starting were our old good architect left the code we could try to modify it a bit. For example:

public interface Server<T extens Connection> {
   T openConnection(ConnectionDetails connectionDetails);
}

I know what your going to say...does that even compile? But looking at it more closely the changes are really minimum. We are just declaring a generic server that has one unknown parameter. But not completely unknown , at least we know it will be some kind of Connection object. But didn't we have that already covered with the old example? Yes..and now. Let's see an implementation. First we are going to use an abstract base class with some minor checkings:

public abstract class AbstractServer<T extends Connection> implements Server<T> {

   protected abstract T doOpenConnection(ConnectionDetails connectionDetails);

   public final T openConnection(ConnectionDetails connectionDetails) {
      ..do some checks...
      return doOpenConnection(connectionDetails);
   }

}

The only interesting bit of the above code is the way we carry the generic parameter down the hierarchy. Till when? Until the final Server implementation:

public final class SubversionServer extends AbstractServer<SubversionConnection> {

   public SubversionConnection doOpenConnection(ConnectionDetails connDetails) {
      ...
   }

}

See the difference now? The openConnection returns a specific class so the compiler checks the types for us! No more downcasts in the process! No class cast exceptions at runtime. And finally something to be proud of to show to your colleagues ;-)

PS.- In case you're wondering where that code actually comes from I'm happy to announce that I've started a new Open Source project at Google Code: IWebJTracker. It's in its infancy right now but with time it will become an issue (project?) tracker built completely in Java. Think of Trac or Project Tracker. Why I'm doing it? For two reasons: first so IWebMvc has a poster child application, second because there are no good OSS Java issue trackers. And by good here I mean with good Maven integration..Sonar...Hudson...see where I plan to go?

PSS.- Any help is gladly welcome :-)

IWebMvc2 Release Candidate 10 available

2009-07-19T02:22:00.001-07:00

For the last month or so I've been able to devote some time to IWebMvc2 and now it pays dividends. I've just uploaded a new Release Candidate and I'm well on track for a final release at the beginning of September.

This new version has several interesting upgrades.

Obviously the most notorious are the two new widgets: Multifile upload and Gallery. The former allows the user to upload a number of related documents and group them in the server as one entity. Documents can be added or removed as needed. It's been built from scratch as I wasn't happy with the matching widget in version one. Visually:

Gallery is a direct consequence. It will show all the images from a MultiDocument in a slideshow manner. It's a direct port of the same widget in IWebMvc or a ThumbnailPicker from Dojo.

But the improvements do not end here. I've invested a lot of time to increase performance. The use of Hibernate batch has, at least, halved the boot time (DB populate has gone from over a minute to less than a few seconds) and offers a better response overall. The client has benefit from the new crop of browsers greatly and the demo application runs smoothly on FF 3.5 and Chrome 2 (IE continues to be my bane).

Other minor issues include:

This release is based on Maven2 instead of Ant+Ivy
Dojo 1.3.2, SoundManager2 upgrade et al
Sonar quality assurance (including core refactorings and new unit tests)
And add the usual bag of bug fixes..

Of course, this is the first publicized version in a while so you may have missed...

The link widget:

Or the poll widget...

Or the many other...just check and enjoy!

Quality assurance with Sonar

2009-07-10T02:56:00.000-07:00

It's incredible how unknown a tool like Sonar is yet. I guess Gradle suffers the same destiny. After all, they're both similar in their intent, improve the quality of your software. It seems lots of people know about unit testing (not so many about code coverage), less know about tools like Checkstyle or FindBugs (static analysis of code) and just a minority are aware of other esoteric metrics like cyclomatic complexity. And even the few that use all of them do not extract all the value that a dashboard provides. That's what Sonar handles, it will take your project and stress it showing the results in a visually appealing site. With no extra work from you, the only requirement is to use Ant or, preferably, Maven.

But seeing is believing so I'll try to convince you showing the whole process and what kind of enhancements you'll be getting. As the demo project I've chosen IWebMvc2. I've nearly finished the development by now so it's a perfect timing to improve quality. In addition it's a complex web application made of three different sub-projects so something must arise. IMHO the quality of the code is pretty good, in theory I just want proofs...did I just say humble? ;-).

The first task is downloading the project and installing it. It's trivial believe me (well as long as you know how to unpack an archive...). To run Sonar just go to the bin folder, select your OS and execute the provided script. Trivial again. Sonar show be accessible (although empty) at http://localhost:9000 by now. Go there and login with admin/admin. Select configuration and under Quality Profiles click on Sonar way with Findbugs: set as default.

Next step is to build our project and include the Sonar phase. This is done typing:

mvn clean compile sonar:sonar

Pretty easy, wasn't it? If the project was built successfully the console was updated and shows something like:

A quick glance reveals a row per project analyzed indicating the number of rules violated and the coverage of the unit tests. There's a little bug with the latest JDK and Cobertura that reports 0% coverage always. As a workaround use JDK6_Update13 for example. The build time reflects how long ago was this information retrieved (not how long took the build itself, tricky). One click on the project shows the dashboard (this is a trimmed version):

Here's the bread and butter! All kind of metrics! From the whole project. The graphic displays the number of modules (JARs) and the relative size of each one. It's used to drill down and get module specific statistics. In fact, every link allows to navigate to new pages with deeper details.

Our task is to improve the quality of the project (bit by bit) so we can navigate to the Violations section and get a detailed report of the problems:

The rules are divided in several areas, some are require while others are optional. Selecting one rule gives the complete list of locations where the code fails to comply. Selecting one of those locations highlights the code:

In the above example Sonar has detected a private method that is never called. For performance and maintainability it should be removed altogether. Now, this is not true at all because I KNOW this method is called using reflection. So I should just ignore this error (caution! static analysis tools are not perfect!). Otherwise I could simply open an IDE and correct the mistake.

Of course Sonar remembers previous scenarios and can track the project life cycle (time machine they call it). Ideally you should be tying Sonar with a Continuous Integration server (out-of-the-box includes a Hudson plug-in).

I'm not gonna lie, quality requires effort. Even if you're an outstanding programmer. Sonar will just help (a lot actually) by providing visual and reporting tools but expect a slow (sometime tedious) climb to the top. Fortunately, in the end, it pays dividends.

Finally...Maven

2009-07-07T10:13:00.000-07:00

I've always been a happy Ant user. Even more so since Ivy has been available. Obviously that puts me in one side of the fence and I've been a very proactive supporter of that kind of project configuration. I must admit that included some rants about Maven here and there. In my biased opinion Maven lacked the flexibility that Ant provided and it was all about dependency management which was handled fine by Ivy. Probably my lack of confidence (knowledge) with the tool had some influence there too.

Four things made me reconsider my position: Hudson, Sonar, Netbeans 6.7 and the amount of time I was spending writing scripts. At work I had to install a CI server a couple of weeks ago and I was not using CruiseControl if at all possible (bad bad memories, I guess). That left Hudson as the best option (well, for me). I spent some time through the documentation and quickly realized that Maven was quite more straightforward than Ant this time. I needed a quality tool as well and Sonar has always been on my radar. Sonar works (again) out-of-the-box with Maven and requires some extra configuration with Ant. Being the lazy developer that I am I decided to test Maven with one project and see the results.

My first impression was pretty favorable. Migrating a simple Java project was a breeze and setting the job in Hudson trivial. I had the statistics online in less than half an hour. Finally I was understanding what was so good with Maven. It was not transitive dependency management, it was Convention over Configuration with the added benefit that other people where writing very interesting plugins for me. With absolutely no work on my side I had an automated build, quality control (testing plus quality assurance) and Jetty running. By now, I was in love with Maven. In more detail:

Zero configuration
So much time lost with Ant refurbishing the same scripts time and again...

Dependency management
I found Maven quite easier to handle than Ivy. I really really missed the master configuration of Ivy though (it saves time when you don't want transitivity for any reason).

IDE support
Today all major IDEs include seamless integration with Maven2. Latest Netbeans release, in particular, works wonders (the reactor plugin is awesome). Ivy support is scarce by contrast.

Redistribution
I've had to invest quite some work, many times, to offer Ant+Ivy scripts along with different project files (Eclipse, Netbeans, IDEA) to appease all kind of users. Not any longer. POMs are treated as first class citizens everywhere now. With the added benefit that I'll be able to upload the builds to the central repository.

Future
I'm under the impression that things like OSGi will be pretty much simpler with this approach.

All in all, I'm leaving Ant. For good. I can't say anything but praises about Ant, it's been years of comradery. And yes, it's a somewhat sad situation but I can't help seeing it obsolete, overridden..

Web framework comparison - Prototyping

2009-05-24T13:05:00.000-07:00

Some may say I have a biased opinion on the topic at hand. True. I hereby declare that I have a clear preference for dojo+DWR+Spring MVC. But I happen to have a cruel client as well and when they asked me to prepare a comparison between several modern web frameworks they purposely left Spring behind. The aim here was to build quick prototypes of enterprise applications to test new ideas proposed by the business people. Obviously they current architecture is a little bit outdated and not suitable for the task.

They gave me a blank sheet to start although they did mention Ruby On Rails and GWT. The first one was in the origin of everything, a new board member had recently joined the company and in his former position they were using RoR for the task. The second was probably due to the fact that several projects had spawned recently with Flex+BlazeDS as the client side technology but noone was really sure if it was the right path.

Given this requirements I selected Seam, AribaWeb and Grails as well.

Obviously this is not an apples-to-apples comparison. Ariba and Seam are both full Java stacks. RoR and Grails are server side backends very oriented to relational database repositories. While GWT is a RIA tool to layout views in pure Java with some communication middleware, like say, dojo+DWR or, as already mentioned, Flex+BlazeDS could be.

But it makes for an interesting analysis anyway.

The criteria to elect the champion contain the following points:

Learning curve
We are talking about three hundred programmers that haven't ever coded in anything but JSF 1.1. Let's make the jump feasible.

Prototyping
How suited for the task is the project? A scripting language seems better to throw something quickly even though it's not maintainable later. On the other hand, a good IDE with good component integration, a drag'n drop visual editor and a preview screen makes stupidly easy to churn pages.

Productivity
How good are the APIs and third party libraries? How much code and configuration is needed to kick start a project? How easily is to connect client and server development?

CRUD
Enterprise applications today always need to interact with a persistent backend.

Killer features
Selling points for the upper management. What does this framework better? Where does it really shine? What unique characteristics does it put on the table?

Weakness
And what about these...?

Maturity, popularity
Is it a safe choice? Will it be around in the not so distant future?

There were others but neither as interesting (licensing, standardization) nor useful to you (migration, code reusability) so these make a good list. I'm not posting the tabular data for two reasons, first it depends heavily on the weights you assign to each column and second it's subjective and I don't want to start a flame war.

But here are my personal conclussions.

In the first round both RoR and GWT fell off the roaster but for very different reasons. In the case of RoR it scored very well in every technical category but, even if I could use it, the truth is a company like this is pretty commited to Java/JEE and such a rupture means time and money. And they're both scarce this days. Maybe for highly innovative teams in core areas but not as a general purpose tool. GWT didn't fare equally well. First for a RIA builder it lacks a decent widget library. Then I like DWR remoting better(biased again?). And finally it shuns standards like a plague. With this conditioning you're better served by Flex. Any day.

The second round saw, and this was a suprise, Grails fail. Grails happens to have the same punch as Rails and then some more. A great ORM that simplifies greatly CRUD operations (nothing really can beat code generation and a book.save()), scripting capabilities, joint compilation, Spring et al. Unfortunately it lacks a matching client plug-in. Flex is not there yet and dojo is too much work for a solution specifically looking for speed of development. The syntax is concise but many times awkward and in general Groovy/Grails still lack maturity (IDE support is minimum, plug-ins quality varies greatly, too many bugs yet). I guess you get used to Java's 24 months release cycle with bullet proof quality. Groovy is different in this aspect. I have good feelings about it (more with SpringSource behind the projects) but it takes time.

The two final candidates provide the full stack, client and server. Seam is IMHO more powerful and a safer choice in general. The people behind Seam are the same that participate in several JSRs and other high profile projects like Hibernate. JBOSS has always been a very active OSS player and the quality of the components (EJB3, Richfaces, JBOSS Tools, Hibernate) is out of question. There's very little bad I can say about Ariba. It's new (very new) in the OSS space and the look&feel is not spectacular (subjective I know). That last bit was important because you want the wow factor when showing a innovative project to the final user. I have to admit that JSF weighed in favor of Seam here but in the end it was a worthy winner for us this time. Kudos to them!

Book review - Spring Web Flow Web Development

2009-05-12T03:05:00.000-07:00

This article was promoted to JavaLobby as well

Right now there are two trends to develop web applications, either you choose the RIA model or a conversational approach. In the former, say Flex with Cairgorm, both the model and the state is handled by the client. In the later, the server manages the scope sending a view to the browser which acts as a renderer. Of course, interactivity has improved over the years and nowadays partial requests are a must to improve user experience. Spring WebFlow is the SpringSource approach to a server side (work/page) flow management for web applications and Spring Web Flow Web Development, the book, (I could think of better names!) tries to explain how to leverage it.

The task is not minor because, let's face it, Java is a very complex platform and to start with WebFlow you should have a good understanding of JEE (at least JSF and the Servlet APIs), Spring and MVC in general. AJAX is welcome as well. The book, of course, can't help you there (you'd need a whole collection for that). This is not for novices! Fortunately a lot of people have learned JEE and Spring through the years and it's a matter of learning Webflow step by step but in depth.

Now, here the book shines. I like the formating, very clear and clean, and the language, simple and direct. I would have changed the chapter structure a little though. I missed individual chapters for persistence (Security has one) and Spring MVC (Faces has one) and I would have reordered some things here and there (configuration is scattered) but that's subjective and overall the steps make sense. The concepts (flow, action, state, transition, continuation) are well defined and you get a grasp pretty soon but some times the book is too comprehensive like when enumerating the methods and fields of the available variables (messageContext, flowExecutionContext et al). This makes for a hard reading but it will be invaluable as a reference book to some. I prefer IDEs for that task though. In the same sense I missed more diagrams and graphs (I'm not referring to UML class diagrams here). In a book about flows it should be pretty easy to plot concepts using some circles here and there. In my mind, circles are not less valuable than XML snippets (the book has tons of these don't worry) and the reader will gladly accept some pictures to clarify concepts (and thank you for them). Nothing too fancy, this one (extracted from the book) is more than enough:

In summary, the book is extensive and a great tool to learn first, and as a reference guide later, to Spring Webflow. It's dense and it explains lots of concepts in depth. Be warned that to extract all value this book requires previous knowledge of complex notions, among them: Spring, JSF, AJAX, persistence/ORM, Security, unit testing and probably more. The authors have made the effort to introduce all these libraries/skills when they're first used but that just lessens the burden (a bit). All in all, an easy candidate to recommend to those who need to extract all the power that Webflow 2 has to offer or teams that are about to start a new project and need an initial push with the technology.

PhoneGap, my new toy

2009-05-08T02:34:00.000-07:00

The best thing about being a consultant is the fact that you have to work for different clients and different projects all the time. My last assignment included a lot of Flex and, now, mobile development.

Being a lazy developer, as I am, I tried to find similarities with web development which, well, feels comfortable. PhoneGap is a OSS project to build cross-mobile (native) applications using the familiar HTML/CSS/Javascript stack. It currently targets Android, iPhone and BlackBerry. This last one was the most important for me this time and, unfortunately, the one that was lagging behind, with a poor overall situation (the maintainer had abandoned development).

No problem, that's the beauty of Open Source development! A quick look at the code (because that's actually the best available documentation) and I got a good idea of the intents both in iPhone, the core platform, and BlackBerry. It seemed that many lines were copied from the BlackBerry documentation and did not serve any obvious purpose. Given that the current code was failing to execute in the simulator I started to refactor...here and there, you know? By the afternoon I had a preview version with a Javascript Hello World and I was pretty happy. I sent the code to the PhoneGap team and got a warm welcome and some advice. Another day and I've been able to submit to the mailing list a working implementation of part of the API: telephony, vibration, location (GPS) and device information. Not bad for a couple of days! Even more so knowing it was my first mobile development ever (a fellow co-worker had to show me the use of the simulator...endless shame).

And now for Windows Mobile...a much bigger job given that there's no code to start with. An implementation from scratch and with C#. Too daunting a task indeed! Let's see how it turns out.

Google App Engine account active

2009-04-08T11:33:00.000-07:00

I've been lucky I guess. I've been looking for affordable Java hosting options for ages and now Google offers me a great alternative for free. I'm just installing the required SDKs and plug-ins. From there some changes to the core of IWebMvc2 to get security going and I hope to be able to create a home page with the demo application running! Thanks Google.

Update: It won't be that easy I guess. Missing Hibernate support (though JPA is available) means loosing all the related functionality (validator, search, extensions to the standard, ...). Some parts can be swapped with little effort but I'll have to devise something for the rest. Good times ahead

IWebMvc2 stable release available

2009-03-25T05:04:00.000-07:00

A quick post just to mention I've compiled and uploaded a new IWebMvc2 version. Although it includes a Beta version of dojo most things work (minor issues with image preview in IE remain). It packages two new widgets, Panel and Chart (though the later is considered preliminary and it's not enabled in the demo). The Panel widget allows a user to freely move content around the screen, collapse it or drag&drop it to enabled zones.

Apart from those this release includes loads of bug fixes and is nearly final. It's been tested under FF3+, IE 7/8, Chrome and Safari with good results (of course, report any issues you can find).

The demo application is composed of several pages this time (instead of the CRUD widget alone) so the developer can see how widget composition does work. In addition this time I've chosen a full download (instead of Ivy) to achieve a better user experience when just evaluating the framework. It should be much faster this time, with a boot time under a minute (unfortunately HSQLDB still needs to be populated on startup).

My next steps include a deep evaluation of other Java web frameworks including Grails, Ariba Web and Oracle ADF Faces. Obviously each of those have unique characteristics difficult to replicate (and, well, more workforce) but that makes for an interesting goal, doesn't it?

I hope you enjoy it!

I'm no Javascript ninja..and you?

2009-03-23T12:19:00.000-07:00

It's a sad confession to make but true nonetheless. Of course, I'm not a newbie either, I know the basics of the language, how to work with objects and functions and, of course, closures. I've even read (probably not that thoroughly) the Javascript Bible. But, for example, it was just last week that I met loop closures for the first time. A loop closure is a language construct where a function can be applied to the traversed elements:

for (i in [0, 1]) (function (i) {alert(i)}) (["a", "b"][i])

I was amazed really. For me, the former solution to that problem (a scoping issue of the loop variable but read the whole article if in doubt) was usually along these lines:

function loop(array, fn) {
   for ( i in array) fn.call(array, array[i])
}

loop(["a", "b"], function(i){ alert(i) })

Now, how much more elegant is the first snippet? It's like programming in Groovy, sometimes you are just surprised by the power offered by those one-liners. I have to admit that without the proper knowledge, the first time you face that kind of code is, well, daunting.

But, to the topic, I was reading John Resig (highly recommended) and I stumbled upon:

var obj = (function() {
   var a = 21;
   return {
      fn: function() {a;}
   };
})();

var foo;
eval('foo=a', obj.fn);

The above code was engineered to showcase a FF problem when handling evals. I wasn't designed for anything meaningful don't worry. But in the process it happens to include interesting tidbits like private variables and the call of a function just after it's been defined. The really weird part are the two last lines where it assigns the foo variable (using an eval) in the scope of the function resultant of the anonymous function invocation. Well, it required me some time to understand that. What brings me to the current situation, I'm no JS ninja you see?

JS has so many gotchas with inheritance and polymorphism that I'm not sure I will understand them all, ever. Then there are all the web issues like cross-browser, cross-domain, XSS, sandboxing et al. Even though I'm programming an OSS web framework (IWebMvc) and it's quite capable, I hope, I still have issues with topics like namespaces! Not to mention if I should offer out-of-the-box support for things like Google Caja. And that's after battling hard with other topics like cache, encapsulation, minification, gzipping, XHR, the many APIs AND the functionality itself. I don't wonder anymore why people find Javascript so fearful and find monstrosities like JSF palatable..

So, what takes to be a ninja? Well, first of all this code should not pose any problem:

Function.prototype.bind = function(){ 
   var fn = this,
      args = Array.prototype.slice.call(arguments),
      object = args.shift(); 
   return function() { 
      return fn.apply(object, 
         args.concat(Array.prototype.slice.call(arguments))); 
   };
};

There you have an augmented native object (Function), private variables declarations, the "full" Array API and closures, of course. And, fortunately, a tutorial here. Once there, you should be aware of browser native APIs, for example, querySelectorAll or the new native JSON parsing support. You have to be in touch with the future of the web (worker threads, HTML5..). Canvas knowledge seems pretty useful as of today as well! Are you up to the task? My only advice, read the dojo or jQuery sources, there are no better tutorials out there. And then...the challenge ;-)

Glassfish v3 embedded, are we there yet?

2009-03-18T13:35:00.001-07:00

I've been preparing a new Release Candidate of IWebMvc2 (get it here). This time I wanted to part from Jetty as, although easy to setup, the results were not that amazing (a first access of around forty five seconds required to compile a complex JSP that relies on many tag files). And I've been following closely the development of Glassfish v3 (I really hope IBM does not buy Sun) so this seemed like a perfect opportunity to test the new embedded server feature.

I started collecting some information from here and there and it seemed easy. I just needed a new repository location

<ibiblio name="glassfish" m2compatible="true"
   root="http://download.java.net/maven/glassfish" />

And a couple of lines in my ivy.xml file

<dependency org="org.glassfish.embedded" name="glassfish-embedded-api"
   rev="3.0-Prelude-Embedded-b14" conf="run->default" />
<dependency org="org.glassfish.embedded" name="glassfish-embedded-web"
   rev="3.0-Prelude-Embedded-b14" conf="run->default" />

Unfortunately GFv3Embedded does not offer any Ant tasks yet so you need a Java class. Something like:

EmbeddedInfo ei = new EmbeddedInfo();
Server server = new Server(ei);
server.start();

Tedious but hardly a showstopper. On the bright side the server instance is fully configurable and, for example, a pool/datasource can be added via code (mimicking the admin console commands)

CommandExecutor ce = server.getCommandExecutor();
options.setProperty("datasourceclassname", "myDataSourceClass");
options.setProperty("DEFAULT", "myConnPool");
ce.execute("create-jdbc-connection-pool", options);

Or a WAR deployed dynamically

options.setProperty("DEFAULT", "c:\\temp\\iwebmvc2.war");
ce.execute("deploy", options);

So far so good. The surprise came later while executing the script. Just take a look of a trimmed version of the output

[ivy:retrieve]  found org.glassfish.embedded#glassfish-embedded-api;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.distributions#web;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.distributions#nucleus;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.osgi-platforms#felix;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found com.sun.enterprise#hk2;0.3.32-prelude-b28
[ivy:retrieve]  found com.sun.enterprise#hk2-core;0.3.32-prelude-b28
[ivy:retrieve]  found com.sun.enterprise#config;0.3.32-prelude-b28
[ivy:retrieve]  found com.sun.enterprise#auto-depends;0.3.32-prelude-b28
[ivy:retrieve]  found com.sun.enterprise#tiger-types-osgi;0.3.32-prelude-b28
[ivy:retrieve]  found org.glassfish.core#api-exporter;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found com.sun.enterprise#osgi-adapter;0.3.32-prelude-b28
[ivy:retrieve]  found woodstox#wstx-asl;3.2.3 in public
[ivy:retrieve]  found org.glassfish#javax.xml.stream;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.core#glassfish;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.core#kernel;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.common#glassfish-api;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.common#internal-api;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.admin#config-api;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.common#common-util;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.external#grizzly-module;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.common#stats77;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.deployment#deployment-common;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.external#asm-all-repackaged;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found com.sun.pkg#pkg-client;1.0.7-15.1269
[ivy:retrieve]  found org.glassfish.flashlight#flashlight-framework;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.flashlight#flashlight-agent;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.admin#monitoring-core;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.admin#admin-cli;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.admin#cli-framework;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.admin#launcher;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.branding#branding;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.distributions#nucleus-base;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.docs#basedocs;3.0-Prelude in javanet
[ivy:retrieve]  found org.glassfish.deployment#deployment-admin;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.deployment#deployment-autodeploy;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.external#javadb;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found javadb#javadb;10.2.2.1-20070823
[ivy:retrieve]  found org.glassfish.web#webtier-all;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.web#web-gui-plugin-common;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.web#web-glue;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.web#web-cli;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.common#container-common;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.common#glassfish-naming;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.transaction#transaction-internal-api;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish#javax.transaction;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish#javax.resource;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish#javax.persistence;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.connectors#connectors-internal-api;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish.deployment#dol;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish#javax.servlet;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish#javax.annotation;3.0-Prelude-Embedded-b14
[ivy:retrieve]  found org.glassfish#javax.enterprise.deploy;3.0-Prelude-Embedded-b14
...and so on...

And worse....

::::::::::::::::::::::::::::::::::::::::::::::
::              FAILED DOWNLOADS            ::
:: ^ see resolution messages for details  ^ ::
::::::::::::::::::::::::::::::::::::::::::::::
:: org.glassfish.osgi-platforms#felix;3.0-Prelude-Embedded-b14!felix.distribution-fragment
:: com.sun.enterprise#hk2;0.3.32-prelude-b28!hk2.hk2-jar
:: org.glassfish.core#glassfish;3.0-Prelude-Embedded-b14!glassfish.hk2-jar
:: org.glassfish.core#kernel;3.0-Prelude-Embedded-b14!kernel.hk2-jar
:: org.glassfish.common#glassfish-api;3.0-Prelude-Embedded-b14!glassfish-api.hk2-jar
:: org.glassfish.common#internal-api;3.0-Prelude-Embedded-b14!internal-api.hk2-jar
:: org.glassfish.admin#config-api;3.0-Prelude-Embedded-b14!config-api.hk2-jar
:: org.glassfish.common#common-util;3.0-Prelude-Embedded-b14!common-util.hk2-jar
:: org.glassfish.common#stats77;3.0-Prelude-Embedded-b14!stats77.hk2-jar
:: org.glassfish.deployment#deployment-common;3.0-Prelude-Embedded-b14!deployment..
....and many many more....

What was that? A horror movie? In the end I was able to find a JAR file that packaged every dependency (glassfish-embedded-all-10.0-SNAPSHOT.jar) but it looked like overkill (I don't want EJB, JMS, ...). At least I've learned something: Jetty works wonders for me, it's just I hadn't realized it fully :-)

So kudos to the GFv3 team, a full blown embeddable Application Server is a nice feature to have. But there's work till it reaches (something that resembles) a mature option.

Parallelism in Spring

2009-03-07T02:22:00.000-08:00

Update: This article has been promoted to Dzone

I've been wanting to post about parallelism in Spring for ages by now. It's an interesting topic that doesn't get the attention it deserves(if any at all), probably because an IoC container and Spring in particular really shine managing dependencies, a task that intuitively promotes serial processing, and also because JEE APIs (say Servlet or EJB) hide the need of it. There's a specific area where no matter what you'll be looking for concurrency and that is data retrieval. As long as a couple of different resources are involved, or even one alone if the data requested is independent, there are efficiency gains processing the several connections in parallel. A common case in todays environments would be, for example, calling web services.

Standard Java does not really offer any API to manage concurrency once inside a request (though the request itself is managed from a pool). In fact, it's open for discussion if the standard forbids opening new threads in a web context (it's specifically banned for EJBs). WebSphere and Weblogic proposed an alternative called CommonJ aka WorkManager API. It's a very good alternative when running under those application servers. Spring offers another, arguably even more powerful, option with the TaskExecutor abstraction. It's sometimes preferable, in a Spring environment, because it can use CommonJ as the underlying API but it can also use the Java5 Executor framework (among others) as well, making the switch just a matter of changing a couple of configuration lines.

Let's review how to use the framework. Our only pre-requisite is to have at least two data retrieval services already configured as a dependency of a third bean. All the data retrieval services must share a common interface, I can recommend something like the Command pattern here (beware this approach is not fully followed bellow to better showcase inbound data processing). At this point we're going to change the individual dependencies and transform them into a collection, we'll add init and destroy methods and an executor (let's start with a JDK5 implementation):

public class ParallelService implements InitializingBean, DisposableBean {
   private List<Command<T>> commands;
   private ExecutorService executor;
}

With our current implementation based on Java 5 executors we need to start up the thread pool in the initialization method and conclude everything when Spring context is closed:

public void afterPropertiesSet() throws Exception {
   executor = Executors.newFixedThreadPool(commands.size());
}

public void destroy() throws Exception {
   executor.shutdownNow(); // Improve this as much as liked
}

We just need to handle the concurrent execution now. It's easy to do with the Future management of asynchronous tasks. Another alternative is to submit all tasks and await termination (see ExecutorService):

public void execute(Data data) {
   Set<Future<?>> tasks = new HashSet<Future<?>>(commands.size());
   for (Command command : commands)
      tasks.add(executor.submit(new RunCommand(command, data)));
   for (Future future : tasks)
      future.get();
   //Other stuff to execute after all data has been retrieved
}

The code above just creates a collection of Future objects to check when the jobs have finished. The tricky part is the creation of the concurrent job from a custom service and pass the required data (if needed). An inner class wrapper will suffice:

private static class RunCommand implements Runnable {
   private final Data data;
   private final Command command;
   public RunCommand(Command command, Data data) {
      this.data = data;
      this.command = command;
   }
   public void run() {
      command.execute(data);
   }
}

Well, that was pretty easy indeed. Right now we have a perfectly valid way to invoke beans in parallel. This approach has pros and cons. In the former list we have independence from Spring APIs (of course imagine that the Spring interfaces are substituted by their matching XML attributes) but we are also limited to a Java5 environment. If we don't mind introducing a dependency with Spring itself we can transform the source code to use the TaskExecutor framework:

public class ParallelService {
   private TaskExecutor taskExecutor;
   private List<Command<T>> commands;
   public void setTaskExecutor(TaskExecutor taskExecutor) {
      this.taskExecutor = taskExecutor;
   }
}

And now the init and destroy methods are substituted by some XML configuration:

<bean class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
   <property name="corePoolSize" value="5" />
   <property name="maxPoolSize" value="10" />
   <property name="queueCapacity" value="25" />
</bean>

But notice that not all implementations of the TaskExecutor interface allow tracking the progress of a task once scheduled for execution!

public void execute)( {
   for (Command command : commands)
      taskExecutor.execute(new RunCommand(command));
}

Hands on with Alfresco WCM

2009-02-15T03:13:00.000-08:00

Recently, during a pre-sales meeting, I was asked to prepare a demo of Alfresco's Web Content Manager solution. They were interested in a product that could ease the work with the static part of the web. Basically, they needed a tool to generate dynamic content that could then be exported to static HTML resources served by an Apache. In Alfresco this means filling templates based on web forms.

I hadn't touched Alfresco since version 2 so I was glad with the opportunity. As a matter of fact I hadn't ever even launched the WCM module as I've been always more interested in the Enterprise Content Manager (the document manager). But Alfresco is growing fast in this space and now has an important set of tools (in beta) like Studio or Share that handle this kind of environments.

All in all, Alfresco WCM is pretty complete. In fact, it only has a weak point, the total lack of useful documentation (not commercial pamphlets). I guess this is a corollary of the OSS business model they've chosen. Sometimes community support just means exactly that, COMMUNITY SUPPORT.

So, let's make the platform work in some quick steps!

The first thing to do is to download the latest nightly build of Alfresco Labs 3 from http://dev.alfresco.com/downloads/nightly/dist/. The nightly build has been more stable than the promoted versions in my tests. Go figure. I'm assuming you have MySQL working already here (if you don't, install it first). Once downloaded just install it (keep the defaults except, may be, the OpenOffice integration tools).

Unfortunately, this version is affected by a notorious bug that impedes rendering content from a XForm (and hence publishing anything useful). A custom build of the web-client JAR file is required. To do it check out the HEAD revision from their repository (svn://svn.alfresco.com/alfresco/HEAD) and modify two source files as explained in http://forums.alfresco.com/en/viewtopic.php?f=30&t=7467&st=0&sk=t&sd=a&start=15. Build just by issuing an ant command. Keep the generated JAR.

Download now the deployment module from http://sourceforge.net/project/showfiles.php?group_id=143373&package_id=157460. This one is needed to publish generated content in a file system (even if local).

It should be installed inside /deployment. Once installed modify the application context XML file and indicate the target directory.

<property name="targetData">
   <map>
      <entry key="default">
         <map>
            <entry key="root"><value>C:/../Apache/htdocs</value></entry>
            <entry key="user"><value>admin</value></entry>
            <entry key="password"><value>admin</value></entry>
            <entry key="autoFix"><value>true</value></entry>    
         </map>
      </entry>
   </map>
</property>

Start Alfresco for the first time using the alf_start script. It will generate the database schema and explode the application(s). Stop it and replace the WCM JAR with the one built from Subversion (in WEB-INF/lib).

The installation is complete (for now). To start Alfresco follow this steps:

Start the Tomcat virtual server support executing virtual_start script
Start Alfresco using alf_start script
Go to the deployment folder and start the server with deployment_start

The login console is available now in at /alfresco. The Web Projects space should be available under the Company Home menu option.

A new web project can now be created. Everything should be working so you can add a test server,

some web forms (the "extras" folder in the Alfresco installation includes several XSD and XSLT templates)

and/or the default workflow.

A nice addition to any installation today is docasu, a web/desktop (AIR based) UI to the Alfresco repository with a focus on easier document handling.

To install it, once again, checkout from SVN at http://code.optaros.com/svn/docasu/branches/docasu-on-air
and follow the instructions at their wiki. Basically you need to build the plugin, copy it to the amps folder in the Alfresco installation and execute the apply script (if the generated WAR does not include the modified web client JAR override it again). The desktop app requires an additional step (two if you don't have the air SDK already). I had to modify the exec task in the ant build file to include the complete path and manually download the mnt jar (from sourceforge) though. Once done, double click the icon in your installation directory and login to http://localhost:8080/alfresco. Just the same as with the web client!

Desarrollo de aplicaciones con IWebMvc2 - Parte I

2009-01-26T04:53:00.000-08:00

Sin duda el espacio reservado a los frameworks web en Java está abarrotado. Los hay de todos los tipos, desde el tradicional Model2 (Spring MVC) al basado en componentes (Wicket). Tenemos alternativas que se ejecutan completamente en servidor (Seam) a algunas que trasladan gran parte de la lógica a Javascript procesándose en la máquina cliente (DWR). Tenemos librerías especializadas en aplicaciones CRUD (OpenXava), con su propio lenguaje dinámico (Grails), patrocinadas por fundaciones o empresas potentes, orientadas a entornos móviles y más. Todas ellos facilitan el desarrollo y en general están orientados al desarrollador. La pregunta es, ¿entonces por qué IWebMvc?

La respuesta es simple, una vez evaluadas todas las alternativas y decida la mejor para una aplicación concreta es muy posible que encontrar que lo ideal es un framework para la lógica de negocio, otro para la capa de web, componentes ricos para el cliente, integración de la comunicación cliente servidor, una capa de abstracción para el acceso a datos, seguridad y más.. Esto es lo que se denomina "full stack", es decir, un entorno. Seam, por ejemplo, provee uno basado en EJB3 y JSF. Pero ¿y si no interesa una aproximación basada completamente en servidor? Pues la lista se acorta a pasos agigantados. Ante esta situación existe una alternativa como Appfuse que integra muchos frameworks distintos pero ofrece muy poca funcionalidad añadida. O realizar la labor de integración individualmente, lo cual requiere un plus de esfuerzo. IWebMvc ofrece una plataforma completa perfectamente configurada basada en los, bajo una opinión personal, productos más interesantes y potentes en el entorno Open Source en Java que son:

Spring
Un contexto de inyección de dependencias específicamente diseñado para funcionar como middleware ofreciendo la misma capacidad que un servidor de aplicaciones pero de forma modular. Sus extensiones para web (MVC, Webflow) y seguridad son reconocidas como de lo mejor del mercado. Y es prácticamente ubicuo en el desarrollo de Java empresarial.

JPA/Hibernate
El estándar para el acceso a base de datos con la capacidad de un ORM muy potente que además extiende la base con posibilidaddes como la cache de segundo nivel o la búsqueda por texto libre.

DWR
La herramienta más sencilla para eliminar la barrera entre las diferentes metodologías a la hora de programar código cliente y código servidor.

dojo
No existe una alternativa con una licencia OSS equivalente y que aporte tanto soporte al desarrollo en Javascript como una librería de componentes AJAX tan completa.

Groovy
De manera que se pueda prototipar rápidamente código con un lenguaje dinámico.

Y más...
Como, por ejemplo, JAWR, una librería dedicada a la distribución de JS/CSS de manera inteligente (¡que además esta desarrollada por otro español!), The Legion of Bouncy Castle para criptografía, Ant+Ivy para la gestión transitiva de dependencias o JasperReports para los informes.

Es posible partir de cero en la configuración de un proyecto con estos mismos pilares pero ¿que sentido tendría? Hoy por hoy, IWebMvc en su version 2.0 ofrece la mejor integración entre Spring/DWR existente. Y no es ésta una afirmación baldía ya que el propio desarrollo de IWebMvc ha impulsado el diseño y codificación de muchas de las mejoras que incluye la version 3.0 de DWR (en la particular de la parte relativa a la integración con Spring), como ha podido ser el escaneo de la vía de construcción, el mejorado soporte de anotaciones, los conversores integrados con el contexto, etc. Probablemente incluso no sería descabellado incluir dojo en este mismo apartado ya que no existen muchos proyectos que ofrezcan out-of-the-box este nivel de entrelazado.

Pero IWebMvc va un paso más allá e incluye un soporte CRUD completo basado en AJAX (como todo en el resto del proyecto). Es decir, sin haber codificado una línea de código, el desarrollador obtiene un entorno configurado y la gestión de cualquier tipo de entidad persistida en una tabla de la base de datos. Y además todo esto construido mediante widgets reutilizables de manera que es posible gestionar la creación de nuevas pantallas en base a la paleta existente así como extender ésta mediante nuevos tags.

Para terminar este primer artículo conviene repasar aunque sea de una manera somera parte de la lista de componentes de la plataforma. Las capturas son del tema por defecto e idioma inglés pero, por supuesto, esto cambia a voluntad del usuario.

Básicos
Los campos de texto, moneda, fecha, listas de valores, checkbox y otros del estilo estan perfectamente representados. Por ejemplo:

Avanzados
Existen widgets utilizables en formularios (con una correspondencia en servidor) que se alejan del típico campo de texto. Por ejemplo, la carga de ficheros, el de puntuación, la selección de color, el texto internacionalizado...

Tabla paginada
El componente de tabla paginada es la base sobre la que se desarrollan un número importante de los componentes más complejos. Entre sus funcionalidades destacan la carga vía AJAX, la paginación, la ordenación, la recolocación de columnas, la ocultación dinámica de columnas, el menu contextual o la selección múltiple. Una tabla paginada tiene una correspondencia uno a uno con una entidad de la base de datos. El desarrollador sólo necesita indicar cual.

Seguridad
CAPTCHA, identificación o desconexión son funcionalidades ofrecidas por defecto. Como siempre, todo por AJAX.

Localizador
Construido sobre la base de la tabla filtrada (una capacidad extra de la tabla base) permite referenciar el objeto actual con otras entidades de la base de datos. Estaríamos hablando del lado izquierdo en una relación 1-N (o una clave externa o foreign key).

Colección
Para tratar las relaciones 1-N desde el punto de vista contrario

Direcciones
Algunas entidades comunes que acaban por incluirse en todas las aplicaciones como puede ser pais, provincia, direccion o sexo vienen predefinidas y con sus widgets particulares. ¡Integrados con las APIs AJAX de Google!

CRUD
Finalmente, el widget mas complejo de la plataforma permite trabajar con una entidad listándola (con filtros o búsquedas estilo Google), creando informes, trabajando en modos de vista o edición, modificando los registros, generando nuevos objetos o eliminando filas existentes. ¡Incluyendo entidades anidadas!

Por supuesto, no todos los componentes tienen interfaz gráfica. Por ejemplo, IWebMvc ofrece hasta tres almacenes de datos (data stores) compatibles con dojo o incluye tags para encriptar datos en cliente, generar identificadores únicos, claves internacionalizadas acopladas con el Locale de Spring o la inclusión inteligente del Javascript en una página (cumpliendo con las normas de rendimiento de Yahoo!).

En el próximo artículo explicaré como configurar una aplicación con IWebMvc 2.0 y como generar una página como la de este vídeo en cinco líneas de código. Para ir abriendo boca la aplicación de demonstración está disponible en el repositorio.

JavaFX, Mario and me

2008-12-31T02:05:00.000-08:00

I guess I am a decent programmer. At least, I've been able to contribute some code to DWR and/or IWebMvc. I could even say that I don't hate Javascript if that holds any value. But, anyway, I've always been bugged by a musing though...

The sad thing is I'm a proficient programmer of "enterprise" (read web) applications. I've always been afraid of not been a REAL coder. Say a Linux hacker or even better...a videogame programmer! You know the kind of people that deliver things like Call of Duty!

I've always blamed my lack of imagination (I'm no game designer) or creative skills (probably a 6 year old kid draws better than me). But with time I've come to conclude that it's just fear. If the graphics are the problem there are multitude of game sprites around the net. And you don't need to invent something new really, a classical shooter or platform game fits the bill perfectly to start.

So I decided that enough is enough and I had to try and make a video game (and become a Tier-1 developer). Well, as a matter of fact, I don't pretend to build a complete one (or some fancy 3d graphics...for now). Just a character that moves on screen and jumps to get coins will be enough to begin. Something like one of my all-time-favorites, Super Mario World. And I can even get the original sprites. Good!

Unfortunately, I'm proficient with Java, Groovy or Javascript but I'm not sure they're your best bet to code a Super Mario clone. I thought about Visual Studio Express C++ for a moment but, really, that was not feasible. C++ after Java seems like a trip to the past. What about something new and shiny? Something related to the Java world if possible? What about JavaFX? Said and done I was downloading the FX plugin for Netbeans and looking through some samples and tutorials.

My first impression was...why the hell do they call this Java??? Yes, be warned, the syntax and the structure is all new. But it packs some interesting features! The bind keyword was a nice surprise (it's like joining a pointer with its referenced value). How useful! The IDE support can improve though. It's still in it's infancy. I'm eagerly waiting for new versions. But watch for the preview mode, it detects changes on-the-fly without even saving the file and shows them on screen.

Soon I realized I needed to use the ImageView (to show images) and the Timeline object to process animations. Using the bind keyword profusely let's you modify a variable and cascade changes in multiple places. By the way, you don't have to worry about concepts like Double Buffering, the platform handles them for you. That's pretty good for newbies. So how does a view look like in the end: a Stage object with a Scene inside that packs a group of components

Stage {
   title: "Mario sprites"
   width: 250
   height: 120
   scene: Scene {
      content: [
   ]
}

Add some vars to control state:

var x = 115.0;
var state = 0;
var currentAnimation : Timeline;
def positions : Image[] = [
   Image {
      url: "{__DIR__}../resources/front.gif" },
   Image {
      url: "{__DIR__}../resources/spin.gif" },
   Image {
      url: "{__DIR__}../resources/left.gif" },
   Image {
      url: "{__DIR__}../resources/right.gif" }
];
var activePosition = bind positions[state];

And a component:

ImageView {
   translateX: bind x
   translateY: 10
   image: bind activePosition
}

The animation will be fired by a radio button as I yet haven't figured keyboard events. Notice that a change in state automatically changes the image and a change in the X axis magically repaints the image component:

SwingRadioButton {
   ...
   onMouseClicked: function (event: MouseEvent) {
      if (currentAnimation != null) currentAnimation.stop();
      state = 2;
      currentAnimation = Timeline {
      keyFrames: [
         KeyFrame {
            time: (x * 1s) / 50
            values: [
               x => 0.0 tween Interpolator.LINEAR,
               state => 0 tween Interpolator.DISCRETE,
               currentAnimation => null tween Interpolator.DISCRETE
            ]
         }
      ]
   }
   currentAnimation.play();
},

And here's the result, 100 lines of code and three hours of work later:

All in all, much better than I expected to achieve given that this has been my first try managing any kind of graphics or animations and I had zero experience with JavaFX. The technology is really great though it needs maturing. I'm looking forward to seeing JavaFX views in Spring applications for example. And I have yet to read some tutorials about server side integration. But it has been a refreshing start. Follow my advice and give it a try!