I blogged earlier about the fact that JTeam is offering Wicket trainings for the Dutch market. However, I feel the need to explain a little more why we at JTeam feel Wicket is such an useful technology for us and our clients.
Let me start off by providing some background on the web frameworks we currently use within JTeam. In general we roughly distinguish three categories of web applications with their own distinct requirements:
- Rich Internet Application (RIA) (a.k.a. ‘Filthy Rich Client’, a.k.a. ‘Fat Client’)
This category of applications make up applications which tend to depend heavily on rich user interaction to accomplish certain day-to-day tasks. They are typically build as a fat client, containing part of the application logic and only communicating with a server backend when really needed.
- General-purpose, public website
As opposed to the previous category, this category makes up interfaces that people do not use to perform day-to-day tasks (although some spend a large part of their workday on Facebook and the likes). These applications usually require SEO friendliness, fast loading, and etcetera. However, they also usually require some enhanced interactivity (read: Ajax, Web 2.0) but only when indexability and accessibility are not compromised.
- Miscellaneous website
The last category holds those applications that do not belong to the previous two. Usually these are the more low-level like applications like a search engine frontend designed to just publish content retrieved from a search backend and / or content repository. But this might also be a REST-like API for a partner program or mobile application.
For each of the above categories, JTeam has its preferred technology to build these applications. For instance, we prefer GWT and Flex for the first category and usually fall back on Spring MVC (especially since the addition of @Controller and REST support) for the third one. But for the second category, we tend to use Wicket as our preferred web framework. The remainder of this blog post tries to explain why.
As with any development framework, what we are looking for in a web framework are things like a good abstraction over lower level constructs (e.g. request and response), state management (when needed), convention over configuration and support for things like Ajax. This is why component-based web frameworks have become so popular. In short, component-based web frameworks bring Object Orientation (OO) to web development, allowing developers to write reusable components and use these to assemble a page that is rendered to the user. Frameworks like Tapestry, the different Java Server Faces (JSF) implementations (e.g. JBoss Seam) and of course Wicket are component-based.
But Wicket has some clear benefits over the other component-based frameworks:
- Clear separation between logic and view
In Wicket the view is in standard (X)HTML and the logic is defined in Java. This makes it really easy for web designers to focus on the design while the programmers focus on the Java code. So no mixing of the two using JSP or something similar.
- No configuration in XML
All of the Wicket specific configuration can be done in your Java code. Although this is not an important benefit for everyone, it is for some.
- Promotes reuse
Although all component-based frameworks promote reuse to some extend, Wicket does that even more partly because of the previous two points. Having a clear separation between logic and view and having configuration in your Java code allows you to easily reuse those components and configuration.
Already using Wicket?
Are you already using Wicket on one of your projects or are you considering to use it? Let us know so we can share experiences and best practices or maybe you have some issues we can help you with. And keep in mind that we have scheduled a public Wicket training (June 8 and 9) in Amsterdam, which might be interesting for you or any of your team members. More information about this and other upcoming Wicket trainings can be found on our website: http://www.jteam.nl/specials.html