Tuesday, December 05, 2006

DNS Analysis and Debugging

If you have to deal with any DNS configuration or want to do some analysis on any other existing DNS, DNSstuff.com might just do the trick for you...Including analysis such as DNS reporting (pretty useful since it can point out any errors you might have in your DNS entries), spam database lookups, DNS record retrieval, among many others, this is a time-saver and a great find. Another tool for my tool belt.

Revision: since I put up this post, DNSstuff is no longer free. A shame since this was a way cool and useful service.

Sunday, November 19, 2006

Unit Testing Struts 2.0

Edit: for latest on this see recent post.

Unit testing is now (or should be) an established step of the development process in any project. If you're not writing unit tests, you are pretty much leaving yourself ready to commit errors over and over again. Granted there is a category of testing other than unit testing that can be put in place to give you that safety net (see WebTst ;-) ) but unit testing has it's well deserved place in the must do list.

Testing however will only happen, let's face it, if it becomes dead easy (or close to that) for developers to write tests. Crunch time has the tendency to make developers drop their testing efforts and if putting them up is in any way hard or cumbersome, it will not happen.

So I started looking at simplifying unit testing for Struts 2.0 (recently merged from WebWork). This is, IMHO, a pretty smart and elegant web framework (topic for another post maybe) that if you have not seen, should take a look at. I am using TestNG for my testing framework (again, a topic for another post maybe, again a pretty smart framework). One of the selling points of WebWork and Struts 2.0 was the idea that testing your actions should be pretty simple due to the nature of the framework. Dependency injection would be a good step to achieve simplicity in testing and allow you to detach yourself from the need of a servlet container to run your tests.

And so I dived into trying to add unit testing to my Struts 2.0 actions. Here is what I would like to do ideally to test my actions purely:

Action myAction = getAction("myActionUrl");
String actionResult = myAction.execute();
and to test my actions with the interceptor chain in front of them, something which I believe should be pretty important to test in the context of Struts 2.0:

ActionProxy myActionProxy = getActionProxy("myActionUrl");
String result = myActionProxy.execute();

I would then like to do testing on results coming out for execution of the actions. Both testing on result strings and testing on HTML returned in the case of the action proxy where we can get access to the fully processed response. Ideally I would like to make it as simple as above, could make it a bit more involved in some cases...but it should always be dead-easy to write a test. So the answer (to me) is a support class to help with writing unit tests. Ready for code dump ? Here it goes, snipped in the non-relevant aspects. Class implements the singleton pattern and relevant methods for Struts testing are:

* Class constructor, take care of Struts initializations
private StrutsTestCaseSupport () {

// create the struts+spring integrated object factory
// set spring autowiring by name for spring object factory
StrutsSpringObjectFactory objectFactory = new StrutsSpringObjectFactory();

// set system object facory

// set action proxy factory
ActionProxyFactory.setFactory(new StrutsActionProxyFactory());

// create a web application context instance (for spring configuration)
_applicationContext = new XmlWebApplicationContext();

// get ahold of a servlet context to use in the creation of the application context
ServletContext servletContext = createOneServletContext(_applicationContext);

// complete application context initialization, pass in servlet
// context and config file location, force reading of config (via refresh)
_applicationContext.setConfigLocations(new String[] {"WEB-INF/applicationContext.xml"});

// initialize the object factory with the mock servlet context, application context

// add a default dispatcher to the system
Dispatcher du = new Dispatcher(servletContext);

// pass over to the configuration manager location where struts-default.xml,
// struts-plugin.xml and struts.xml can be found, force reading all
_configurationManager = new ConfigurationManager();
_configurationManager.addConfigurationProvider( new StrutsXmlConfigurationProvider("struts-default.xml", false));
_configurationManager.addConfigurationProvider( new StrutsXmlConfigurationProvider("struts-plugin.xml", false));
_configurationManager.addConfigurationProvider( new StrutsXmlConfigurationProvider("struts.xml", false));

* create a servlet context useable for a specific action
* @param applicationContext the application context to use in the servlet context
* @returns the created servlet context
protected ServletContext createOneServletContext (ConfigurableWebApplicationContext applicationContext) {
// create a servlet context for this action, use FileSystemResourceLoader for
// context to find configuration files
ServletContext servletContext = (ServletContext) new MockServletContext(new FileSystemResourceLoader());

// initialize freemarker manager config parameter to null (let FreemarkerManager figure
// out configuration location out of ServletContext)
Settings.set(StrutsConstants.STRUTS_I18N_ENCODING, "UTF-8");

// hand over application context to servlet context
servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, applicationContext);

return servletContext;

* Build one action context for an accessmethod and an access url
* @param serverName the hostname that the request will need to hook up to
* @param accessMethod http method to use (e.g. 'get', 'post', 'put', etc)
* @param accessUrl the url to access
* @returns the map for the action's context
public Map buildActionContext ( String serverName, String accessMethod, String accessUrl, Map requestParamMap ) {
// get ahold of a brand new servlet context
ServletContext servletContext = createOneServletContext(_applicationContext);

// create fake request and response objects
MockHttpServletRequest request = new MockHttpServletRequest(servletContext,accessMethod,accessUrl);
MockHttpServletResponse response = new MockHttpServletResponse();

// set request server name

// add request parameters
for ( String oneParamName : requestParamMap.keySet() ) {

// add context, request and response to an action context map
Map actionContext = new HashMap();
actionContext.put(ActionContext.PARAMETERS,new HashMap());
actionContext.put(ActionContext.DEV_MODE,new Boolean(true));

return actionContext;

* create a bean from the object factory (all wired up from Spring)
* @param beanName the name of the bean to get from the object factory
* @param extraContent any extra content information to pass along to the bean building
* process
* @returns the object factory created bean
public Object createBean ( String beanName, Map extraContext )
throws Exception {
return ObjectFactory.getObjectFactory().buildBean(beanName,extraContext);

* create an action proxied by it's interceptor stack
* @param actionName the name/id for the action
* @param actionNameSpace the namespace for the action
* @param actionContext the action context for creating the proxy (created from buildActionContext)
* @returns the proxyed action
public ActionProxy createActionProxy ( String actionName, String actionNamespace, Map actionContext)
throws Exception {
return createActionProxy(actionName,actionNamespace,actionContext,new HashMap());

* create an action proxied by it's interceptor stack
* @param actionName the name/id for the action
* @param actionNameSpace the namespace for the action
* @param actionContext the action context for creating the proxy (created from buildActionContext)
* @param sessionMap the request/invocation session map (for http session map mocking)
* @returns the proxyed action
public ActionProxy createActionProxy ( String actionName, String actionNamespace, Map actionContext, Map sessionMap )
throws Exception {
ActionProxy actionProxy = ActionProxyFactory.getFactory().createActionProxy(_configurationManager.getConfiguration(),actionNamespace,actionName,actionContext);

// set the session map in the action proxy's invocation

return actionProxy;

* create an action object, bypass all it's stacks. Have it properly injected
* according to configurations.
* @param actionName the name/id for the action
* @param actionNameSpace the namespace for the action
* @param actionContext the action context for creating the proxy (created from buildActionContext)
* @returns the properly injected action
public Object createAction ( String actionName, String actionNamespace, Map actionContext )
throws Exception {
// get ahold of the action's configuration via the XWorkConfigRetriever class
ActionConfig actionConfig = _configurationManager.getConfiguration().getRuntimeConfiguration().getActionConfig(actionNamespace,actionName);

// create one instance of the action to test using the object factory, pass in action config and context
return ObjectFactory.getObjectFactory().buildAction(actionName, actionNamespace, actionConfig, actionContext);

With this support class, I can now write my tests:
       // create action context for my action, feed
// into the action context all request parameters
Map requestParameters = new HashMap();
Map actionContext = StrutsTestCaseSupport.getInstance().buildActionContext("my.hostname.com","get","/myActionNamespace/myActionName",requestParameters);

// create the proxy for the action, this encapsulates all
// the interception stack up to the real action
ActionProxy proxy = StrutsTestCaseSupport.getInstance().createActionProxy("myActionName","myActionNameSpace",actionContext);
// if needed be, get ahold of particular action underlying proxy and
// inject parameters as required

// let the full stack run
String result = proxy.execute();

// confirm result
assert result.equals("myTestResponseString");

// look into mock HttpServletResponse, do whatever
// tests I need to do: returned HTML, returned headers,
// cookies, etc...
String responseXml = ((MockHttpServletResponse)actionContext.get(StrutsStatics.HTTP_RESPONSE)).getContentAsString();
assert responseXml.indexOf("success") != -1;
Or test unproxyed actions directly:
       // create action for my action
Map requestParameters = new HashMap();
Map actionContext = StrutsTestCaseSupport.getInstance().buildActionContext("my.hostname.com","get","/myActionNamespace/myActionName",requestParameters);

// create the proxy for the action, this encapsulates all
// the interception stack up to the real action
Action myAction = StrutsTestCaseSupport.getInstance().createAction("myActionName","myActionNameSpace",actionContext);
// if needed be, get ahold of particular action underlying proxy and
// inject parameters as required

// let the full stack run
String result = myAction.execute();

// confirm result
assert result.equals("myTestResponseString");
So testing became *a lot* simpler to me...my support class deals with all infrastructure hooking up and my test is simplified...and more tests get written... ;-)

Wednesday, November 15, 2006


Last year I dove into the iPod addiction...Maybe not very typically, I really did not get into it because of music but because of technical podcasts. Music I can do in a number of other ways but the amount of technical podcasts that are out there for free is just overwhelming and it can be a fantastic source for free training and technical news feed. I have not regretted diving into it yet and am currently in a iPodaholic state. This is a fantastic way to make your commute useful and pleasurable. Ironically I now think my commute is just too short (got me an iTrip FM transmitter to hook it up to my car radio). :-) Podcast shows are getting more and more interesting and show durations are getting longer with deeper more involved content coming in. To any developer these days I say that listening to podcasts is now an essential way to keep up to date, in addition to book reading, playing with cool stuff after-hours, magazines and blogs (and I wonder where time goes!?!!?). I should also be saying that podcasting is not only about technical podcasts.....there is pretty much a podcast for any thing you might think of.

Anyway, these are the must-have-on-my-iPod podcasts:

  • The Java Posse: in my opinion, the best podcast out there on Java development. These guys do news info update, analysis of tools, overall software development discussions. Absolutely top of my list.
  • Software as She Developed: pretty interesting podcast on software development. The author Michael Mahemoff is the author of the Ajax Design Patterns book so you can expect this podcast to bring in a good amount of that experience.
  • Audible Ajax: name says all, a really good podcast on Ajax.
  • Software Engineering Radio: good presentations on software engineering in general. Covering topics like agile development, SOA, development processes, etc.
  • Javapolis: one of the best Java conferences around. You can find podcast feeds for some of the presentations in here. A free way to "be" at the conference.
  • TalkCrunch: a really interesting podcast on web 2.0 companies.
  • Venture Voice: talks and discussions on entrepreneurship.
  • PodTech's Entrepreneurship Podcast: talks and discussions on entrepeneurship.
If you have not tried the podcasting listening experience I would say you need to try it! You can try it before you buy your player just by getting iTunes for instance...

And...if you have any other interesting tech podcast please drop me a line! I want more! :-)

Friday, October 13, 2006

Tizra Blog is alive!

Tizra's blog is now alive! In there you should hope to find the Tizra's team ramblings on the web publishing world...technical hints, development process observations, geekly comments and cool notes on what is going on. The blog is alive at http://tizra.blogspot.com/. I will be splitting some of my blogging time between this blog and the new Tizra blog, but putting on the new blog some more focus on what we are doing at Tizra and practices that worked there. Check it out!

Sunday, October 01, 2006


Wikis should now hold, I believe, a crucial place in every development team's utility belt. Information sharing, knowledge transmission, they all represent fundamental aspects of the development process within a team. There are a ton of wikis out there (e.g. see JSPWiki for instance) that provide the full features that will allow for this information knowledge base repository to be implemented.

Now, sometimes wouldn't it be nice to have a small personal wiki to jot your thoughts, todo lists, tips and tricks ? Something that you probably would not want to store on a shared wiki. TiddlyWiki gives you just that. For starters it is pretty impressive the ease in which you can start doing something with it....You just download a single html file (loaded with javascript functionality) drop it into a directory on your disk and access it via a browser. That's it. no more installation steps/tools/servers required! You're up-and-running ready to start writing. How cool is that ? And bringing features like tagging, RSS this brings an even more useful experience to the mix.

Yet another tool in my tool belt (will probably need a new belt sometime soon...mine is getting too crowded...;-) ).

Another tip picked up at the No Fluff Just Stuff conference. :-)

No Fluff Just Stuff Impressions

Damn you Jay Zimmerman for making my life so hard during the No Fluff Just Stuff conference days ;-). For two and a half days you made me go through the excruciating pain of having to choose one presentation for each time slot...I mean...you could have put boring, uninteresting sessions in there to make my life easier but nooooooo...you had to give us a choice of absolutely fascinating topics presented by brilliant speakers. And pretty much at all time slots ? Come on....I came back refreshed and enthusiastic from the presentations, exhausted from the selection process.

Now seriously (in case you have not picked up *yet* that I'm joking), the No Fluff Just Stuff conference was simply fantastic. The organization, and Jay Zimmerman in particular, did a fantastic job of putting this together. The place was pretty well setup, the materials were really good and organized, the topics impressive (I would have gone to all of them could I clone myself!), the speaker list really overwhelming. You would get to hear the presentations in decently sized rooms (not huge theater like places like other conferences), you would get to interact with the speakers (in and out of the sessions) to ask questions and just exchange ideas. And there were even nice goodies raffled among the audience (I was not one of the lucky ones to get a prize but hey, that was not what I went there for ... obviously still trying to rationalize! ;-) )

In short...count me in for the next one! This is a hidden gem of a conference!

And, if you could not make it, you can still get the No Fluff Just Stuff Anthology from any shelf of any good tech bookstore (or amazon if you also consider virtual shelves for that matter).

Saturday, September 16, 2006

Blogger Enhancements and Tizra AgilePDF Boasting

Now we're cooking! Last week I upgraded my Blogger blogs to the new Blogger Beta...This new beta adds a couple of new features that I consider to be crucial for a useful and rich blog.

  • You are now able to add tags to my blog entries (have you checked my right navigation bar since then ? ;-) ) thus effectively achieving category grouping of these entries.
  • You can now create private blogs. And why would I want that you may ask ? For small teams it is often useful to have a repository of shared information and/or comments. While for some things the use of a Wiki (see Wikipedia entry for Wiki) fits the bill of storing and sharing knowledge, for others the use of a blog can be more appropriate (not impossible to do via a Wiki, just a bit more awkward). Recent news of interest, cool interesting things out there, these all fall more into the info better usable in a blog.
  • It provides a drag-and-drop interface for blog template management, provides an enhanced set of blogger tags for simpler layout management.
  • It provides an enhanced user interface for some of the blog's visual components, take a look for instance at the new archive navigation tree, pretty cool.
At this point I will have to boast a bit and put in my shameless plug...;-)


Defining page layout structureIf you like what you see in terms of control of the appearance of your blog, you should *really* see what we are doing at Tizra...We are building a web tool for pdf content publishers, the AgilePDF product, that gives the admin user total control over all aspects of their site including presentation, content management, search, access control, creation and selling of admin defined products. The layout definition component in particular is a component that currently really overwhelms what the Blogger page editor is offering, if you liked that one, you should see ours! ;-) It offer the means to change the presentation of the site by providing a pretty nifty drag-and-drop interface for site structuring definition and CSS definition interface.

Publishing ContentThe Publishing experience makes use of currently available rich client technologies thus eliminating the typical "Push and Pray" experience of a good number of publisher applications out there making it possible for people to *actually know* what is going on when interacting with the system.

Published and looking just like you wanted!At the end of the day, a nice looking (actually as nice as you might want to make it! ;-) we offer nice looking canned solutions that might get you started towards a nice looking site but you are free to do whatever you want with it, including make it look ugly if for nothing else to make a statement! :-) ), site is out there with your content properly presented, giving you a nice web-like experience to content that usually is not very web-friendly.


If Blogger was already a nice tool for bloggers and small companies, it becomes even more so after these nice enhancements. I'll keep drilling through the new beta...blogging...

Friday, September 15, 2006

Computer Science Talks

If you are looking for some computer science talks/presentations, Research Channel is a nice gathering place for a whole number of interesting presentations on a number of different topics (and other non CS related topics for that matter). The University of Washington Computer Science and Engineering site also presents a pretty cool list of colloquiums available for public viewing. Spanning a whole slew of CS subjects, from Distributed Storage Systems to Google's Linux Cluster, the list is just too big to reproduce here....

All in all a pretty cool resource for getting to learn a bit more....Fair warning: you could be in there for some serious time...;-)

Wednesday, July 19, 2006

No Fluff Just Stuff

The No Fluff Just Stuff Symposium has been doing the rounds for sometime now...This is an excellent event for Java developers, architects, testers, etc... It usually displays an impressive list of presentations covering a good range of Java and/or Software Development topics and usually brings some pretty interesting names of the Java development community for the presentations. The symposium goes around the country so there is a good chance you might get one close to you...If you have not heard about it, check it out at the No Fluff Just Stuff site.

My registration to the Boston NFJS symposium Sep. 29 - Oct. 1 2006 is already in...See you there! :-)

Tuesday, July 18, 2006

Free books online!

Not a pitch...they are really free. TheServerSide, which happens to be a really good site for java related technical content (got my RSS feed reader hooked up to it, read through the feed always with eager anticipation), is offering a couple of books in PDF format for free. All Java related these include:

You need to register on the site to "get the goodies" but it is worth it. Pretty interesting stuff, yet again, from TheServerSide.

Thursday, July 13, 2006

JavaOne 2006 Sessions Online

Sun has posted the JavaOne conference technical content online. These can be found at the Sun Developer Network site in PDF and multimedia format (audio + slides). Really interesting information in there.

Wednesday, July 12, 2006

Getting organized!

When you work on several things at time it becomes really important for you to track what you need to do, when you need to do it and to be "nudged" when it is time to do them...And along come things like Google Calendar and Airset (among tons of others!). I have personally been using Airset for quite sometime (long before Google Calendar showed up) and have been pretty impressed with what they have. With such an application I can keep separate calendars for my private life and my work. Even within the work information we can keep separate events from different activities (e.g. management roles activities, development activities, staff vacation). Nicest thing, you can have separate views or integrated views....easy enough to provide people synchronization since some of those calendar sections (tabs in their nomenclature) can be made shareable effectively allowing for people to know what each other is doing. And....for people like me that like to be "nudged" you can have as many warnings as you want on an event that is about to happen...

So.....no more excuses...Get organized!

Friday, June 09, 2006

Sharing initialization across Unit Tests

In principle unit tests should be isolated from each other to ensure that running one unit test does not influence another. There is however, I believe, a case where having a shared initialization between unit tests can make a lot of sense. Whenever a time consuming initialization needs to take place, and when one can ensure that the state of the initialized environment does not influence in any way the tests, then it is really important to share initialization. One of the goals of unit testing is to make it easy to test, to promote a test-often approach and that will conflict with long initialization times. An initialization that takes a couple of seconds, although very acceptable for a running application is not acceptable at all for unit testing. If you do follow the test-often approach, you will be building a large number of tests (not hard to admit you will have several dozens, hundreds of tests). Multiply that by the initialization cost and testing becomes unbearable.

Example of the above. I have been working for sometime with WebWork+Spring+Hibernate and using JUnit for unit testing integrated in the build/deployment process via Ant. The startup time for the system is around 8 seconds (still way lower than a full J2EE application server startup time ;-)...but after even a mere 12 tests it becomes impossible to have to wait for a simple test run. By isolating the initialization of WebWork+Spring+Hibernate in a shared initialization class, I was able to reduce the overall tests run time by a huge factor. Somewhere from 104s to 12s in my simple (very simple) case of 12 tests.

The solution for me, I create a singleton class that isolates all shared initialization then I make sure all tests run via ant using the task batchtest with forking enabled and with forkmode set to 'perBatch' (see http://ant.apache.org/manual/OptionalTasks/junit.html) and voila, I get shared initialization and a huge reduction in test running.

After looking online for similar issues, I found the link http://beust.com/weblog/archives/000082.html that talks a bit about this same issue confirming my worries and validating this approach.

My belief in unit testing restored, I continue my development with my nice safety net in place...

Wednesday, June 07, 2006


Every developer "carries" his bag of tools around when doing their work...This bag of tools can represent a precious advantage since a good tool applied at the right moment can bring speed and quality to the development effort. It is quite unlikely you will find a tool that "fits all" (a tool for each job) and the developer does need to know enough of the tool and problem to solve to make it useful (it is not the weapon that makes the warrior, it is the warrior that makes the weapon). But sure enough, some tools are just too good and should be in every developer's bag. A tool which I found to be a must for any serious web developer doing from just regular HTML coding to AJAX development is the Firebug Firefox extension (you are using Firefox right?!?! ;-) ). The tool allows you (among other functionality) to:

  • Inspect HTML, by moving your mouse around you can get to see the HTML snippet relevant to the element highlighted on the browser.
  • Inspect properties like positioning, styles on inspected HTML elements.
  • Inspect events happening in your pages.
  • Inspect the DOM of your page.
  • Perform Javascript debugging.
  • Show all AJAX interactions between your page and the underlying server.
  • Show all kinds of errors (e.g. CSS, Javascript, etc)
In short, if you are doing web development and have not seen Firebug in action before, you should spend sometime looking at it...It will save you hours in any future development. It sure is in my bag of tools to stay. :-)

Wednesday, May 17, 2006

Eventum Issue/Bug Tracking System

I had been looking for an issue bug tracking system in my spare time...I had of course had previous encounters with several bug/issue tracking systems (BITS :-) ) but had found them to be either not very useful in terms of information gathered and reporting (e.g. several in-house built/adapted systems I've worked with) or overly complicated for simple bugs/issue reporting (e.g. Bugzilla). Do you really want to have your users go through the pain of a million selections to report a bug, especially when most of these selections do not make sense to a user of your software ? Do you instead use a system from which you can not extract information how you want it ? After some browsing around, I have bumped into Eventum a BITS from the MySQL AB technical support team. I have been surprised with what I have seen so far....Here is a list of things which impressed me:

  • Reporting format configurable per user role. You can hide those nasty fields from your end-users, but still allow these fields to be visible/manipulated by higher privileges users. Decision control to where it makes sense to be.
  • Built-in release planning. Bug resolution can be assigned to specific releases of your software giving you a nice planning tool synched with your BITS.
  • Integration with Source Control Management (SCM). Pretty cool that you can have your SCM synch with the BITS to have software check ins cross-referenced with bug/issues.
  • Reports. Loads of them....Pretty useful the majority of them.
  • Time tracking (a dear topic of mine...See TrackItEZ). The system allows for bug/issue fixing estimation, tracking of time spent and reporting on estimate deviation.
  • Pretty cool nice visuals on overall bug listings...Eye candy I know, but often a picture is worth more than a thousand words... ;-)
  • Definition *per project* of priority definitions for bugs/issues. You can not believe the amount of people complain about the kind of priorities BITS impose on you...Roll your own then....It is a fact that bugs/issues priorities definitions *should* be different depending on the kind of project you are working with (a web served application project is indeed different from a pure desktop applications, different worries, different types of issues).
  • CSS driven design...Yup...You are free to make it as ugly looking as you want... ;-)
  • Email bug/issue reporting: you get to configure email accounts to receive bugs/issues into the system. Nice.
  • It's open-source and free (GPL).
I will indeed be playing more with it but so far it looks like these guys got their stuff right....Bravo! I'll keep using it and see if I keep liking it as much as I have been so far....

Sunday, April 09, 2006

Java Server Faces in Action

I have recently been looking at Java Server Faces and, as usual, went through the first phase of trying to understand what is involved in using it....What it can bring in and what are the compromises one has to do when using it. I am a firm believer of a tool for each job and just dove in trying to understand what kind of tool this is...So...I picked up Java Server Faces in Action and went wild with a mix of reading then diving into action (staying true to the philosophy of the in Action series). So here are my conclusions...

The book is actually a good book. Would not say excellent since it spends a whole lot listing components and attributes before diving into application of it. Something which makes for a bit of what feels like a slow reading. That being said, it does expose pretty well what you can do with JSF. Granted it is pretty valuable, but I also found a bit annoying the fact that there are an extra set of 5 chapters and 4 appendixes online and not in the print version (not published after the fact! They are even listed in the book's table of contents!!). There is a reason why I buy hardcopy books and that is that I really like having the print version and be free to read something irrespective of the presence of a internet connection or the presence of a computer with a downloaded PDF. And I really can do without printing an extra set of 270 pages (got to give a break to my home printers!).

What about JSF ? Well, I do get mixed feelings about it and to be honest I do not think that, given the nature of applications I write, I am ready to start using it just right now...Some comments on what I read and played with...
As I read this, I also browsed online for comments and applications of JSF. In particular I listened to the ZDot Podcasts by Tim Shadel. A lot of fuss was raised in the Java community around this podcast (see TheServerSide for instance, a ton more out there). Tim does point out some interesting and somewhat valid issues if JSF. Some are surely no longer applicable since he had been using an old version of JSF and do believe some of the issues he faced (e.g. bad quality of generated HTML) is no longer that much of an issue. I also believe that most importantly he might have missed an important point that you have each tool for each job. After reading and playing a ton with JSF I am convinced that the kind of applications JSF applies to are rich, almost desktop like, web applications and not your regular website.
But he does make pretty good points about some shortcomings of the technology. Taking that and my experiments here is what I liked and did not like about JSF.


  • It is a pretty cool technology with a well thought of architecture. I really like the concept of components and regardless of other comments, I like the 7 layer burrito to implement the life cycle of a component.
  • Being component oriented I do see the huge advantages of getting pre-built components that already do the "dirty work" for you. It is indeed the basis for efficient code reuse. Oracle ADF and Apache MyFaces are just two examples of component libraries for JSF. Both provide pretty cool and useful component sets.
  • JSF has good tool support. If you use something like Java Studio Creator you can quickly take the best advantage of the component-oriented approach of JSF for rich app development (although I also have some issues with Java Studio Creator -- I have a pretty beefed up machine and my god, is this thing a performance hog sometimes!).


  • Getting components to do the work for you prevent you from tweaking what you can do with the generated HTML. That makes sense in the scope of a rich client app, not so much in a web site where you want to get finer control over placement and presentation of all your design items. In particular, interactions with professional designers (usually non-programmers) can be dificult if working from component rendered HTML. Furthermore, some components provide their own stylesheets making it harder for proper integration with a site design.
  • There are components for JSF out there...I played with Oracle ADF and with Apache MyFaces. MyFaces was, by far, a lot more to my liking. Easier to use and deploy into your own app. I had a ton of issues with ADF. Both components libraries miss (IMHO) some more documentation to make them more usable. The goal of components is to make them easy to reuse and that *has* to equate to good documentation.
  • Every interaction involves a full roundtrip. Take for instance validation of fields. This involves a full post to the server, interaction with the component lifecycle and a return of the full HTML back to the client. With things like AJAX around, it does sound a bit hard to swallow that a full roundtrip needs to be performed to do simple validation...it sounds just to heavy for what we should be doing. Granted there are approaches to join JSF with AJAX but they start to sound a bit hybrid solutions and start taking away a bit the nature of JSF. Some components available in the JSF components libs can already be found as lightweight Javascript/AJAX components...something I would rather favor to server side full roundtrip requiring solutions.

Bottom line....I did like the book, I was not 100% convinced by the technology. I see some uses in the realm of rich web applications, I see the elegance of the architecture, I see the advantage of having good components libraries. However I feel it does not give you necessarily the best user interaction experience (POST for every interaction), might not give you ease of control over presentation aspects should you need it (e.g. a complete web site, not just a web app), components are still not that straightforward to use.

I am not jumping into the JSF wagon just yet...

Thursday, March 16, 2006

An official name!

It's alive! We now have a name and a short blurb page about the new company. Tizra is the chosen name. After a careful round with several candidates this is the one that stuck. Check out our blurb page at http://www.tizra.com/.

You might be wondering what on earth does Tizra mean (if anything)...well, check it our for yourself in this A Dictionary of Descriptive Terminology entry.

Friday, March 03, 2006

New Company, New Life!

Big changes in my life! I decided to quit my job at Ingenta and take a shot at starting a new business with two other partners. We are now one week into this....Lots of productive discussions regarding the company structuring, logistics, lots of discussions in fleshing out the product we are going for. We believe we have a pretty cool idea that could gain traction. Next couple of months will tell. I will add to this blog further new company information as it becomes possible to make it public.

I'm sure to continue bumping my head on the wall but with a happy smile on my face...

Monday, February 13, 2006

Lucene in action

I would call this the "everything you wanted to know to get started with Lucene in 70 pages" book. True enough, in a mere 70 pages the authors give you enough information for you to understand the basic Lucene workings and make you feel like jumping into action and starting to do something with Lucene. In addition to that, the book simply throws some gems in there that pretty much solve the issues you would hear mentioned over and over in the context of search engines. Wildcard searching, search optimization, multiple language support (analysers in detail), highlight snippets, search within search, Latent Semantic Indexing, common document formats indexing (PDF, HTML, XML, RTF)...you name it, they probably put in there.

A fundamental read if you want to know what Lucene is all about. Even more if you actually need to use it! A really good read!

Sunday, January 15, 2006

JBoss EJB 3.0 TrailBlazer

A nice EJB 3.0 in JBoss presentation can be found under the JBoss TrailBlazer pages. It allows you to get a quick overview of what you can do with EJB 3.0 within JBoss and the new changes in EJB 3.0. Pretty worth taking a look.

New England Java Users Group January Meeting

I attended the NEJUG January meeting Struts 2006: An embarrassment of riches. This was a pretty interesting and information filled meeting. The future of Struts was discussed, in particular details on the integration between Struts codebase and WebWork codebase were outlined. Looks like WebWork 2.2 recently released will provide the codebase from which Struts 2.0 will be developed upon so the two technologies will merge. Pretty interesting to see as well the underlying Spring support on which WebWork is based, clearly showing the coolness of this infrastructure. This was a full room presentation with around 230 participants and it well worth the 1 hour drive each way to attend. Next NEJUG meetings promise to be pretty interesting as well.

Healing my head from the bumping on the wall [Part 2]

Yup...head feels a lot better...and the reading material was one of the most interesting ones I took on vacation so far...Both technologies have some elements of QWAN and it definitely been showing their influence in latest and greatest developments in the Java community. Just take a look:

  • Hibernate is now the underlying ORM technology for persistence in the likes of JBoss' implementation of EJB 3.0
  • Dependency Injection is also a concept that is being introduced in latest EJB 3.0 (although, IMHO, still awkward in some aspects).
  • Interceptor queue and aspect oriented programming start showing themselves in EJB 3.0 as well (again in a much cleaner fashion in Spring).
  • WebWork 2.2, the future Struts Action 2.0 is based on Spring and brings (as a result) lots of the great ideas of Spring into the mix.

Unit testing in Spring becomes dead easy since, if you follow the Dependency Injection approach as you should in Spring, you can easily use something like Mock Objects to actually inject pretty much all kinds of stand ins allowing you to test code deterministically and without the need for large, heavy or hard to integrate into testing support infrastructures. Web Unit Testing in particular becomes sane to use by following this approach...

More to follow on this pretty soon....