. So congratulations from here

But back on topic: One fundamental rule of the Tapestry 5 framework is, that each page has a corresponding class which contains all (java-) logic for this page. This mechanism works sole with convention over configuration and there is no exception to this rule. At least in standard Tapestry 5 ...In the company I used to work we depended on Tapestry pretty heavy. We had created a couple very good solutions using this framework but we also had some challenges to meet. I guess they are pretty common to web based companies.

• We had to use a CMS system (Magnolia CMS in this case) to enable the marketing and non-techical guys to maintain all the content they are creating.
• We had to maintain a couple of so called landing pages. I guess most of the web guys know and hate them These pages are just an empty shell containing nothing more than some sightly different logos and graphics of partner companies. The also provide a nice URL in most cases like: http://www.mycomany.com/tv, /mobile or /unameit. Unfortunately some of these landing pages hade some minor dynamical stuff on it.
• Most of this landing pages require that you are storing some (voucher) code into your application to modifier your check-out process a little bit.

So, now you have a couple of pages, of which you don't know when they appear - and you really don't want to know, because coordinating the timing with the marketing guys is always a mess -, with very similar structure and functionality. As a matter of fact this case should be a text book example for component reuse. but this is a case where Tapestry 5 and the convention-over-configuration thing works against us.

So what do you have to do in classic Tapestry 5? Jepp you allready guessed it, you have to create a page class for each of this landing pages. Okay thanks to inheritance this class will be de-facto empty. But it is annoying to create this class. You'll have to create a version of your web application, do a QA cycle (if you want to play it right), make a deployment. So you have a lots of communication with a bunch of other departments. In a world with perfect processes you might to accept this, but I guess most of the guys out there know the situation where a junior business consultant guy stands right at your desk telling you of the nation wide TV campaign that launches tomorrow and that needs this new landing page. Maybe some of you already tried to say the 'n*' word

A early solution was to introduce some Meta templates in out CMS. They were some simple HTML comments which where evaluated by a service in our web application and re-assembled via simple Tapestry pages and components. This worked quite well but brought us a bunch of issues - like template caching, dynamic contents in templates, etc. - which are already solved in Tapestry. The solution was also pretty limited in when dynamical and statical parts should be joined together. So I took some time to evaluate a different approach:

My first question was: Is it possible to make tapestry work with pages that do not have a class as backup?

I never tried this, because I figured out, that I actually didn't want to do this, and as a matter of fact, it makes the whole exercise a lot easier. What I did was to make Tapestry use a default class for pages tapestry does not know. I call this pages virtual pages. I'll guess you always have some minor data shared between all virtual pages, so you create on page class that Tapestry may use to serve virtual pages.

So how you serve virtual pages with Tapestry 5.1? I was surprised who simple it was (after some month of the wrong track). So this is, how virtual pages may work:

1. Check if the page exists
   A good place to do this is the ComponentClassResolver with its isPageName(..) method. I created a special implementation of the ComponentClassResolver which decorates the Tapestry original.
2. Mark the request
   Mark the request as request to a virtual page. I used a dedicated service with thread scope for this. You also may compute and store some data in this service.
3. Alter page class loading
   Adapt the loading of the component classes to load (and attach) the default class to the page. Another decorated service does the work here too.

And voila you can deliver content for pages with no backing class, astonishing isn't it? You may look at the small prototype/example project at github and you'll realize how simple the solution is. The prototype is a slightly modified Tapestry 5 archetype project which will serve the URL http://localhost:8080/About as virtual page.

So far, so good! But now some last words if this is a good solution at all. First I want to mention that we had an integration ready for the architecture we used, but it went - for several reasons, most non-technical - never productive.

Let's talk about some oddities first:

• The URLs to address the pages do not fully comply the Tapestry behaviour. In Tapstry it does not matter if you request /About or /about, but the prototype only supports a simple template resolution.
• Some Tapestry components/mechanisms won't work properly. Tapestry uses classes to compute links to pages. Always when this mechanism is used, you'll may get problems. Components like <t:pagelink ...> may not work properly because you do not have a class. Keep this in mind.
• Unexpected Runtime and memory behaviour. Tapestry is a very stable and production ready framework. But we are misusing it a little bit. Keep a close eye on memory consumption because every HTML page will now be a tapestry template and will be cached in the memory of your virtual machine. Some of some infrastructure components are also optimized for a (relatively) small amount of page instances.

Why do I want to use Tapstry this way? The first advantage is the simple creation of new pages. You'll create the .tml file and you are done. We used it with a CMS in the background and with some specialized CMS templates the marketing guys where able to create a bunch of landing pages without troubling an IT guy. In addition to the standard page we used some components which contained the major functions of the pages. So we were able to create instance of this virtual pages which behaved sightly different because we passed some parameters using the TML of the virtual page.

Why does not offer Tapestry this mechanism? First: It's a prototype! If you take a closer look you will se how limited it is. This topic as hole comes across the tapestry mailing list regularly and there are lots of pro's and con's. I don't want to discuss any of them in this blog post. But I agree with the Tapestry guys not to introduce it into the core framework.

At the time I was evaluating this prototype I had some very good reasons to do so and only a few are mentioned here. But if you have a big amount of content it is seldom a good idea to generate templates which are interpreted by a dynamic framework. No matter if you use JSP, Tapestry or even PHP.

I hope you'll enjoyed reading this blog post. I learned much about Tapestry 5 preparing it and evaluating my idea. If you have questions of any kind feel free to contact me

I already made some experiences with the Flying Saucer on another job and it is still a very nice framework for PDF creation. For me, a major advantage of "The Flying Saucer" over other PDF creation frameworks, like XSLT and FOP, in the Web world is the homogenous technology mix.

"The Flying Saucer Project" create PDF from XML/XHTML pages using CSS style sheets. All technologies known to the web designer that gives your web site this pretty look. I guess it's okay when you say, that XSLT and FOP is the more powerful technology mix, but styling pages on this technology mix is not a simple task to do.

So back to the initial topic: A basic ingredient which is needed to create PDFs with the "The Flying Saucer Project" is some XHTML. In our project at scoyo we wanted to use Apache Tapestry to create this XHTML.

After taking a closer look to the Apache Tapestry rendering pipeline I found out, that the PageResponseRenderer is the perfect place to hook up the PDF creation into the rendering process. On the one hand the PageResponseRenderer uses a MarkupWriter to create the (X)HTML content from the current Page instance. On the other hand the PageResponseRenderer is responsible for writing the generated content into the server response.

Using the Apache Tapestry own IoC mechanism it's quite an easy task to decorate the Tapestry PageResponseRenderer implementation. It's a beautiful mechanism when you understood how it works. Okay I guess using the 5.1 version of tapestry it would be better to advice the renderPageResponse(...) method, but I had not enough time to get familiar with it yet.

One real big plus on Apache Tapestry is the implementation. Every function is well encapsulated into separate services. And the service implementing classes are very short and almost always on consistent level of abstraction. So you easily understand how a service works and you are able to copy and extend the service functions. So I extended PageResponseRenderer to determine if a page creates XHTML output which should be transformed to PDF. If no PDF should be created my PageResponseRenderer simply delegates to the original Tapestry instance.

When the page wants to create PDF my PageResponseRenderer buffers the created content and redirects it into the ITextRenderer of the a href="https://xhtmlrenderer.dev.java.net/">"The Flying Saucer". Okay this sounds more nice, than it actually is. The content is stored into a ByteArrayOutputStream and re-parsed by the standard JDK XML parser for further processing by the ITextRenderer. But I guess the we will live with the performance impact until it gets a real issue.

So long explanation short story. The whole thing worked out great! It took me like two to three hours to implement a first prototype. In out web application. This also includes the embedding of custom fonts into the PDF and a nice discovery of pages to render into PDF, via custom annotations using the component model meta-data facilities and a ClassTransformationWorker.

Web development can be so easy when you are using Apache Tapestry. On an earlier project we used a similar architacture with JSP and the "The Flying Saucer". I guess it took us ten times the effort to establish an equal infrastructure using JSF and the Java Servlet API ...

Due to the generosity of Google I got a nice Google wave test account. Now I am looking desperately to some spare time to evaluate the integration of jaev to the wave. One idea is to expand the validation to wave addresses via the wave protocol. Maybe an online validation as wave bot is another exciting idea.

The jaev framework is in productional use at least one installation and no major problems where filed so far. I'm keeping my fingers crossed

I am working already on some new features:

• Caching negative responses of mail servers
  When a mail server refuses communication due to suspected spam, the result will be cached to reduce network traffic.
• Suggest e-mail addresses
  When the validation fails suggest a list e-mail addresses. This algorithm may use the previous request and a default list of domains to compute some suggestions.

If you have any good ideas, file them on the issue tracking system or the google group.

Maybe I am applying for a google wave developer sandbox access to provide a google wave robot for online e-mail suggestion. Bah, that sounds like some work

The second release candidate was built this afternoon. It contains some fixes and some improvements suggested by PMD and Findbugs. Another major focus was to improve the performance of jaev. This was achieved in reducing the number DNS lookups by introducing a cache for DNS MX record resolution.

This may lead to another nifty feature in the next release candidate, final or 1.1 release. I am planning to introduce a domain suggest function. This may be achieved by using a fix/initial suggestion list and the queries against the DNS lookup cache. If everything works out well the i.e. the Tapestry 5 example may offer a suggest function for e-mail addresses.

What does jaev do? The name jaev is the abbreviation for java (advanced) email validation. So the framework does validate e-mails. Sounds quite boring, isn't it? Of course not!

The name of who/what is jaev? The jaev framework is my first open source project! Jepp, I joined the community and giving something back after years of using the frameworks of other people.

What does jaev do? The name jaev is the abbreviation for java (advanced) email validation. So the framework does validate e-mails. Sounds quite boring, isn't it? Of course not! There are some quite good tools for e-mail validation like the one in the Apache commons validator project (I "borrowed" some test cases there). But the e-mail validation in java was quite shallow. If you want to have a more advanced validation, i.e. of the domain, you'll had to do it yourself. The jaev framework tries to fill this gap.

It provides facilities to validate the syntax of an e-mail address with including addresses with names like Niclas Meier <niclas.meier@example.com> (I confess the handling of comments in e-mail addresses has still some flaws, but it's not so important I guess). This is obligatory but the jaev framework offers quite more.

With the jaev framework you'll may check the domain of the e-mail address. The framework uses a local (or server) copy of the IANA top level domain database (http://data.iana.org/TLD/tlds-alpha-by-domain.txt) to validate the top level domain. If the top level domain is okay the DNS database will be queries if the domain exists and has MX entries. If a domain has no MX entries you'll have to assume that you will could not relay an e-mail message to the e-mail address. The mail server uses the same mechanism.

A very important feature of the jaev framework is: You have the choice! You are receiving a Result object as outcome of the validation process. The Result contains a code, which specifies the details, and a validity level which specifies the level of validity of an e-mail address. I.e. SYNTAX suggests that an e-mail address is syntactically valid but the domain and account may be invalid. The maximum validity is ACCESSIBLE. With ACCESSIBLE validity the jaev framework was able to verify the existence and accessibility of the e-mail address on the MTA of the e-mail domain.

This is the last big feature of the jaev framework. The framework can connect to the MTA specified in the MX entry of the domain and tries to send an e-mail to the e-mail address. If the mail transfer can be initiated the framework will abort the process, no mail will be send, but we can assure that the e-mail account exits.

Around the three step validation mechanism the framework offers quite simple and extendible construction and configuration mechanisms, examples for JSF, Tapestry 5 and Flex & BlazeD and different acceptance strategies. Timeouts may be applied on different levels and operations, so you can assure that you'll get a Result in a defined amount of time.

I think this is quite a handy package. And I spent lots of my spare time the last four weeks to bring this to life. Maybe someone out there agrees with me and uses the framework in his application.

If you encounter some problems or you would like to contribute/request some features you may post them to the google group or to the issue management system. Maybe there is someone out there who is firm in ANTLR which the jeav framework uses for e-mail parsing.

So this weekend I read the article about some new Features of the 5.1 Version of the Tapestry framework ...

One of the blogs I am reading on a regular basis is the Tapestry Central blog from Howard Lewis Ship the founder and lead developer of the Tapestry framework. It already provided some really nice ideas and introduced me into some really interesting topics.

So this weekend I read the article about some new Features of the 5.1 Version of the Tapestry framework. And I was really exited to read about the plans to reduce/minimize the traffic over the wire. I am studying this topic for quite a while, since I stumbled across it during a project. The trigger was the Best practices article from the Yahoo developer team.

Since then I was using different approaches and tools to improve the performance of the websites of my clients. One very useful tool is JAWR a Javascript and CSS bundling and compression tool. JAWR offers facilities to join multiple Javascript or CSS files in bundles. Each bundle will be delivered compressed (if possible), in addition very strong cache HTTP headers will be set to the HTTP response, so that the internet infrastructure may cache these files. So the traffic the originating server will be reduced. To prevent nasty caching problems the JAWR framework provides facilities to generate URLs to these bundles which contain a version information, so when the bundle changes, a new URL will be generated.

The very exciting thing about the planned Features in Tapestry 5.1 is, that Tapestry is the first content generating web framework which will provide out the box facilities for this kind of issues.
A great weakness of the JSP and JSF approaches to generate content is, that there is no fast/cheap way to determine a last modified date for a page or a component. So the application can't use the "If-Modified-Since" and "Not Modified" (HTTP status 304) mechanism to provide a lightweight answer for requested resources which have not changed. Maybe Howard Lewis Ship is able to provide this with his Tapestry framework. This would be a great performance boost for any kind of web application.

May very dynamic application don't address the content delivery issues at all. Its quite sad to see, but on the other hand side it's good to see that some frameworks are beginning to address this kind of features.

But I already spent a little time on playing around with Tapestry 5 on my little project. Quit a nice piece of software, but quite some hurdles to get into it. The trivial examples work quite well but I still have some troubles getting my ideas working. But I guess my years of experience are standing in my way now, because I am quite aware of what I am wanting to achieve ...

Maybe this week I have some time to investigate Tapestry 5 more in detail.