Why Picking Technology is Hard

I think choosing a framework is hard because no framework is perfect. Every framework under consideration is like a Porsche with a gaping hole in the side that just ruins it. The very act of choosing a framework means that you are knowingly accepting every little ugly wart and blemish of that framework, and explicitly saying “Yes, I want to deal with that problem everyday for the next few months!”. We aren’t built to choose things that are going to cause problems for ourselves.

It’s one of the reasons I always revisit the state of web frameworks now and again to see what pain points have been cleared up and what new ones have been created.

Context matters when discussing frameworks

As if web framework religious discussions weren’t annoying enough, one thing that I always think is missing from such debates is context regarding the type of application being developed. It’s like discussing the best mode of personal travel without taking the type and size of journey into account. There’s a reason why you walk to the mailbox and drive to the store. You can drive to the mailbox but it will incur costs greater than the benefits. Similarly, you can walk to the store as long as it isn’t too far, you have the time to do so and you aren’t buying much.
Read More »

Conversational CRUD in Java EE 6

This tutorial will demonstrate a pattern for creating CRUD applications in JSF and Java EE 6. While this is not the only way of implementing this mechanism, it does promote re-use and can give you essentially zero code CRUD pages requiring just the view code. The goal is to provide a single structure that provides the particular feature of being both stateless or conversational where we might want a conversational edit page and a stateless view page. This pattern is based on the EntityHome pattern that was used in JBoss Seam and carries over well to Java EE 6 with CDI. This is something I use all the time to make view/edit pages really quickly and unlike most of the automatic scaffolding in other frameworks, doesn’t need re-writing to go into production.
Read More »

Demo Application Using JSF, JPA, CDI with Jetty

The previous version of the Knappsack Maven Archetypes included archetypes for creating projects using JSF, JPA, CDI and Bean Validation that can run in a servlet container such as Jetty or Tomcat. In order to put it through its paces I decided to create a little test social bookmarking application that lets users create accounts, and when logged in, add bookmarks and tag them. Users that are not logged in can view the bookmarks and filter them by user or tag, and the results are paginated.
Read More »

CDI Conversations Part 1

This is the first in a series of articles looking at the conversation scope introduced in CDI as part of Java EE 6. We’ll start by looking at existing scopes and how they introduce limitations for developers and how CDI conversations get around these limitations.
Read More »

Try Java EE 6 without the commitment

The latest version of the Knappsack Maven Archetypes now supports creating Java EE 6 applications for servlet containers. These projects includes configuration for core Java EE 6 technologies such as JSF, CDI, JPA and Bean Validation and can be run from the command line using the embedded Jetty and Tomcat servlet containers.

Also with this latest release, all the archetypes are available in the Central Maven Repository which means you can dive straight in and create a new Maven project using these archetypes :
Read More »