Now I really don’t get this project. At first glance, JAM seems to provide some of the Maven functionality in a nice, structured, way using Ant. The part I don’t grok is that JAM depends on Maven. Huh?

Since I am sure to be missing something and am very interested in build tools, please comment if anyone can do a good job of explaining where JAM fits.

I should now say something witty about Kool-Aid here…

I’m in the process of reading the Trails tutorial by this guy (Trails’ creator) and I am very enthused about the idea: I’ve always felt that code-generation is being overly used in J2EE development. I believe, as do others, that if you can generate it, you should be able to handle it at runtime. (There are exceptions to this rule, of course.) Java has an exceptional reflection API, we should use it. Also, Spring allows much of the work to be done via AOP. But I’m rambling a little here.

The major exception to my dislike of code generation has always been page templates. These are just dumb pieces of text, so you either need to build them by hand or generate them. I’ve never really understood what Tapestry was about until I started reading about Trails and realized that it was allowing us to push object oriented design all the way into the template layer of our applications.

They features of Trails, like allowing us to override the presentation of a specific field without building a template for the entire form and lack of code generation, are really exciting and will provide some great ideas for my current side project.

Those familiar with Plone development will see some similarities here.

A.

Some time ago, I posted a short entry on Maven vs Ant. Since then, I have continued to use Ant while periodically taking yet another look at Maven.

This week, I came across this post on Otaku talking about keeping your Ant builds maintainable using <import> and <macrodef>. Greater maintainability seems to be one of the reasons Maven was created: allowing you to avoid creating build target spaghetti by describing the project and applying standard goals. These new Ant features can provide this maintainability, while keeping all the flexibility we’ve grown accustomed to.

Cedric’s post then led me to this comment thread on techno.blog(“Dion”) where a good discussion is taking place.

Finally, I can no longer remember how I got there, but dependancy management tools for Ant came up. TSS has an Inversoft‘s Verge project and a post on Mallim Ink pointed me to Jayasoft’s Ivy project. Both projects look very interesting; I think I will try out Ivy shortly.

Update: Colin writes about Ivy and seems very positive.

Updated: Since I’ve noticed quite a few Google hits on this entry, I thought I’d post some more information.

I’ve finally figured out what Maven is all about. (No one seems to say it outright.) This enlightenment comes after writing a previous post

The basic difference is fundamental: where Ant allows you to build your own targets to do anything you wish, Maven takes your description of your project (directory structure, etc) and uses standard, pre-written, tasks (goals in Maven-speak) to achieve the usual build needs.

Maven has a bunch of built-in plugins and goals. You can write your own using Jelly.

I’ll be updating this post with some more info shortly. (Ok, so I guess it took a while. My conclusion seems to be staying with Ant, particularly with the addition of new extensions.)

Some relatively clean information is available here

JJAR promises to be a tool/service that the Java community sorely needs. We are all too familiar with Jar hell.

From the site:

A distributed repository consisting of jars from various projects (which we call packages) as well as version and dependency information about those packages. This logical repository consists of a central main repository, and any number of sub-repositories, each responsible for a given project (or projects.)

A toolset to allow the navigation and fetching from this repository, as well as direct access to repository information, such as project dependencies.

The general idea is that you setup a repository for your jars, including full dependancy information, which then allows you to use the Ant task as noted here

However, I see very little activity on this project. CVS has nothing interesting in over 2 years. Anyone know its status?

I do intend to test it this week, even though it seems inactive. (Probably because of Maven

Hot off the heels of confirming that it would open source Solaris, Sun has now semi-officially spoken about the Java platform:

Sun to open-source Java

Keeping track of the tld files for a framework or API is an error-prone process, very much so when using a framework like Struts or JSTL that has multiple tag libraries .

A better solution is to package the TLD files along with the rest of the library’s classes and other resources. This is actually mandated by the JSP specification, but who reads specs anyway. IBM developerWorks has a great series on JSP best practices, or which one of the articles explains this technique:

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

The short explanation is to put the TLD files in the META-INF directory of the jar file and reference them in your deployement descriptor like so:

<taglib>
<taglib-uri>http://www.newInstance.com/taglibs/site-utils</taglib-uri>
<taglib-location>/WEB-INF/lib/newInstance-taglib_1-1.jar</taglib-location>
</taglib>

Some of the other articles in the series are worthwhile as well.

In addition to this simple use of advanced jar packaging, there is a multitude of other abilities that are completely ignored, I will post some more on this subject this week.

Since I do not believe that Struts is the be all and end all of application frameworks, I’ve been looking around at the competition. There are quite a few. Since I believe that this IoC (Inversion of Control) thing is a Good Thing, I’ve restricted my search to those frameworks that manage not only the “actions” of an application but also it’s components.

Currently, there is the following:

• Spring
• Xwork (WebWork 2)

Another possibility is too do something homegrown on top of PicoContainer.

In then end, I realise that it is a very difficult topic. But I have a plan: I want to put together an evaluation sheet for frameworks. Please email me your thoughts and I will condense them into another posting.