Bumping my Head on the Wall

Tizra Publisher Demo

2009-01-20T10:52:00.006-05:00

This is why I have been so quiet...the Tizra Publisher platform has evolved immensely during the last couple of months...which of course means a pretty busy time...and fun for that matter...And we are now posting a video tour of Tizra Publisher...

For a higher resolution demo tour, try this.

Oh...and since we went self-service, you can try a free plan for Tizra Publisher by subscribing for your free site here.

My Essential Firefox Add-ons

2008-07-21T22:10:00.001-04:00

Been too long since I last wrote here. Tizra has been pretty busy picking up a ton of enthusiasm from customers and prospects (see Tizra Blog). That means, of course, a pretty busy time... :-)

I recently had to do a complete reinstall of my development environment. My laptop went dead and I had to get a new one...so that leads to the typical "absolutely essential" lists...today I reinstalled all my Firefox Add-ons. The good thing about reinstalls is that you cut the fat accumulated throughout the years and the absolute musts get installed first. Here is my list of absolute musts (in no particular order):

Selenium IDE: if you're doing any kind of serious development, you want to have a good test coverage. Selenium is a really cool tool to allow you to build automated UI and system integration testing. Selenium IDE makes your life *a whole lot easier* (although not dead-simple). You still have to tweak a lot of the generated code but hey, it's a really great start. And if you have not seen Selenium yet, you have to go take a look. It is not necessarily simple to get into but well worth it!
User Agent Switcher: really nice for that kind of testing that involves user agent detection...you can even "roll your own" agent identification for test purposes.
Web Developer: a really essential set of tools for web development. CSS inspection, changing, DOM information, source viewing, browser resizing, you name it, it's probably here.
Live HTTP Headers: a nice tool to let you see the header flow from and into your browser. Sometimes essential for analysis of behavior.
Firebug: you can't say you do web development and not know about Firebug. Simply brilliant. If you have not seen it yet, tell no one about that and go check it out for yourself.
Delicious Bookmarks: currently addicted to del.icio.us. You can see my bookmarks here.

I'm always open to suggestions on new add-ons...

Google APIs, XML, Ajax and some pretty cool pictures!

2008-03-18T09:36:00.006-04:00

This is what happens when you join in a single "package" an artist and a techie...Marcelino Martins had already assembled a pretty cool site filled with really impressive pictures (see here). With Brazil Pictures, Marcelino joins his photographic artistic talent to his techie talent...he has already developed some pretty cool packages like Treeview...Now he's been playing the Google APIs, XML, Ajax...the result is the really interesting Brazil Pictures. And take a look at his implementation notes for a very interesting read.

Very nice....

AgilePDF is live!

2008-01-22T14:11:00.000-05:00

I am pretty excited to see the first set of AgilePDF sites go live...we (Tizra) are indeed live at this point. You can now see the results of this effort at the following sites.

Francisco Assis Rosa's Publications. Now, would I not be eating my own dog food ? I honestly find the system pretty cool and am publicly using it to store and offer my publications online. Privately I keep a copy of the system on an internal network where I keep all my favorite tech reading. It is really handy to be able to search through the full collection of my favorite texts and get relevant results *to the page*....nice.

eat.shop guides. Some pretty cool eating and shopping guides...smartly written, gorgeously presented.

Rate It Green. Live access digital edition to "Green Building 101".

Why do I feel so excited about this ?

These customers were able to hop on online without any significant investment. We are talking days instead of months between agreement and go live (and that with full design customization!), we're talking about revenue from online selling in the first couple of days. Yup, they did not have to wait six months to see a dollar, or even more to get their money back from the site building investment.
The technology set used in this system is a pretty exciting technology allowing us to take advantage of a lot that's good out there...
I could see a nice use for personal users like me that have some content that want to distribute online. Either free or for sale...you name it.

As far as system features go, these are some of the items that make me believe AgilePDF is cool:

End-user page-at-time PDF rendering, allowing for getting back web usability that was taken back by the placement of unwieldy PDFs online (50Mb PDF downloads to read *one* page anyone? Make that over slow connections ?).
Full text search over the content of the site/sub-site/single document with results returned at the page level (again, instead of result pointing at full PDF).
Full fledged configurable access control over your content.
Full ecommerce configurability. Whoever owns the site can create their own products (including products resulting from combinations of pages from different documents in the site), create their own selling offers and just put it out for the test. We allow hooking up to PayPal and Authorize.Net right now but as requests come in we will be expanding the list of payment fulfillers.
Full site design configurability. We offer some out-of-the-box designs you can use but you can change all the look of your site by dragging and dropping site blocks around your pages...and if you really want to go crazy on your design, just upload your CSS and you can do what you want (just compare Francisco Assis Rosa's Publications to Rate It Green to eat.shop guides!).
Full site structure configurability. Via the administration web interface you can create sub-sites based on filtering of meta data in your documents. When I said "full site design configurability" in the previous item I really meant it, you can even have these sub-sites look completely different from the main site and/or other sub-sites.
Google crawling, analytics and adsense integration...speaks for itself! ;-)

And...you can always drop me a line if you wish to use something like this...

This is just our first release...we are and will continue to work on this...

We are live! :-)

I'm still alive! ;-) ;-) ;-)

Unit Testing Struts 2.0 (Part 3)

2007-09-11T08:58:00.001-04:00

Like Dan commented on the Unit Testing Struts 2.0 (Part 2) post, Struts 2.0 has changed it's API enough to make my previous code not work on latest version. So, in response to his comment, here is what I am using right now. Credit where it's due, the setup code is the one that The Arsenalist pointed out on his blog post Unit Testing Struts 2 Actions wired with Spring using JUnit. Again, credit where it's due...my thanks go to "The Arsenalist" for posting his solution.


/**
* Class for easier support of Struts related
* testing. Takes care of all the configuration details
* that allow test classes to create beans (Spring),
* actions (Struts), intercepted actions (Struts).
* Class is singleton to minimize hit of initializing
* Struts and related infrastructure (e.g. Hibernate).
*
* Adapted from code from "The Arsenalist" (http://arsenalist.com/),
* see http://arsenalist.com/2007/06/18/unit-testing-struts-2-actions-spring-junit/
*/
public class StrutsTestCaseSupport {

   /**
    * Singleton variable
    */
   public static StrutsTestCaseSupport _theInstance = null;

   /**
    * Servlet context
    */
   private ServletContext servletContext = null;

   /**
    * Request dispatcher
    */
   private Dispatcher dispatcher = null;

   /**
    * Singleton access
    */
   public static synchronized StrutsTestCaseSupport getInstance()
       throws Exception {
       if ( _theInstance == null ) {
           _theInstance = new StrutsTestCaseSupport();
       }
       return _theInstance;
   }

   /**
    * Class constructor, take care of Struts initializations
    */
   private StrutsTestCaseSupport ()
       throws Exception {
       String[] config = new String[] { "/WEB-INF/applicationContext.xml" };

       // Link the servlet context and the Spring context
       servletContext = new MockServletContext(new FileSystemResourceLoader());
       XmlWebApplicationContext appContext = new XmlWebApplicationContext();
       appContext.setServletContext(servletContext);
       appContext.setConfigLocations(config);
       appContext.refresh();
       servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, appContext);

       // Use spring as the object factory for Struts
       StrutsSpringObjectFactory ssf = new StrutsSpringObjectFactory(null, null, servletContext);
       ssf.setApplicationContext(appContext);
       StrutsSpringObjectFactory.setObjectFactory(ssf);

       // Dispatcher is the guy that actually handles all requests.  Pass in
       // an empty Map as the parameters but if you want to change stuff like
       // what config files to read, you need to specify them here
       // (see Dispatcher's source code)
       dispatcher = new Dispatcher(servletContext, new HashMap());
       dispatcher.init();
       Dispatcher.setInstance(dispatcher);
   }

   /**
    * 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
    * @return the object factory created bean
    * @throws Exception on processing, configuration errors, test failure
    */
   public Object createBean ( String beanName, Map extraContext )
   throws Exception {
       ObjectFactory objectFactory = dispatcher.getContainer().getInstance(ObjectFactory.class);
       return objectFactory.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
    * @return the proxyed action
    * @throws Exception on processing, configuration errors, test failure
    */
   public ActionProxy createActionProxy ( String actionName, String actionNamespace )
   throws Exception {
       // create a proxy class which is just a wrapper around the action call.
       // The proxy is created by checking the namespace and name against the
       // struts.xml configuration
       ActionProxy proxy = dispatcher.getContainer().getInstance(ActionProxyFactory.class).createActionProxy(actionNamespace, actionName, null, true, false);

       // by default, don't pass in any request parameters
       proxy.getInvocation().getInvocationContext().setParameters(new HashMap());

       // by default, pass along an empty session map
       proxy.getInvocation().getInvocationContext().setSession(new HashMap());

       // set the actions context to the one which the proxy is using
       ServletActionContext.setContext(proxy.getInvocation().getInvocationContext());
       MockHttpServletRequest request = new MockHttpServletRequest();
       MockHttpServletResponse response = new MockHttpServletResponse();
       ServletActionContext.setRequest(request);
       ServletActionContext.setResponse(response);
       ServletActionContext.setServletContext(servletContext);

       // set proper URI
       request.setRequestURI(actionNamespace + "/" + actionName);

       return proxy;
   }

   /**
    * 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 sessionMap the request/invocation session map (for http session map mocking)
    * @return the proxyed action
    * @throws Exception on processing, configuration errors, test failure
    */
   public ActionProxy createActionProxy ( String actionName, String actionNamespace, Map sessionMap )
   throws Exception {

       // create an action proxy as usual
       ActionProxy actionProxy = createActionProxy(actionName,actionNamespace);

       // set the session map in the action proxy's invocation
       actionProxy.getInvocation().getInvocationContext().setSession(sessionMap);

       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
    * @return the properly injected action
    * @throws Exception on processing, configuration errors, test failure
    */
   public Object createAction ( String actionName, String actionNamespace )
   throws Exception {
       ActionProxy actionProxy = createActionProxy(actionName,actionNamespace);
       return actionProxy.getAction();
   }

   /**
    * Access to the proxy's response content as a string
    * @param proxy the proxy to get the string response for
    * @return the proxy's response content as a string
    */
   public static String getResponseContentAsString ( ActionProxy proxy )
       throws java.io.UnsupportedEncodingException {
       return ((MockHttpServletResponse)ServletActionContext.getResponse()).getContentAsString();
   }

   /**
    * Set a hostname in proxy request
    * @param proxy the proxy to set hostname to
    * @param serverName the server name to set for this proxy's call
    */
   public static void setRequestServerName ( ActionProxy proxy, String serverName ) {
       ((MockHttpServletRequest)ServletActionContext.getRequest()).setServerName(serverName);
   }
}

Like mentioned in previous postings, using this class is pretty straightforward, within your test you just do for beans:


    YourClass yourInstance = (YourClass)StrutsTestCaseSupport.getInstance().createBean("yourBeanId",new HashMap());

For Actions:


    ActionProxy proxy = StrutsTestCaseSupport.getInstance().createActionProxy(yourActionId,yourContextPath);
    MyActionClass myActionInstance = (MyActionClass)StrutsTestCaseSupport.getInstance().createAction(yourActionId,yourContextPath);

This code is currently being used with Struts 2.0.8.

Return of the Stuff!

2007-08-29T18:49:00.000-04:00

Here we go again, it's that time of the year where good things are about to happen. September is marked by two major events: the release of Halo 3 ;-) and the return of the No Fluff Just Stuff conference (now called the New England Software Symposium). I have written about this even before but it does not hurt to repeat it...this is a really impressive conference and a must if you live around the Boston area. It takes place during a Friday afternoon and over the weekend. This is actually a great decision since it simplifies a lot the "need to be out of work" argument with your bosses. Sure it takes over your weekend but, if you're in this business you are most probably hooked enough to this stuff for this not to be a problem. The attendance to this event is capped at around 250 which is another great feature since it does allow you to be in those rooms listening to the presentations in a much close environment. You get to interact with the presenters both during the talks and during the breaks by mingling in lunch tables or just approaching them directly. The topics are amazing and, like I mentioned before (see here), the really annoying part of the even is choosing which sessions to go to. The price for the event is really a find...pretty affordable even if, like me, you do not get your company to sponsor you
and pay out of your own pocket.

This fall, the Boston even takes place on the 14th (PM), 15th and 16th of September in Framingham, Massachusetts. For all the details, check out the event site.

I got my place already booked, what are you waiting for ?

Problems with Keyboard Mapping when Running vncviewer on Ubuntu

2007-07-06T09:57:00.000-04:00

In the hope that this adds to the list of solutions out there that can actually help people...
If you are having keyboard mapping issues when trying to connect via vncviewer to a machine running vncserver on Ubuntu Feisty (7.04) with gnome, try this:

Create a ~/.vncrc file and add to it:

        $vncStartup = "<your_home_dir_here>/.vnc/xstartup";

Create a ~/.vnc/xstartup file (or edit) and make sure it contains:

        xrdb $HOME/.Xresources
        gnome-wm &
        gnome-panel &
        nautilus --no-default-window &
        gnome-cups-icon &amp;
        gnome-volume-manager &
        cd ~
        xterm &

Solved the problem for me. Credit where it belongs, found the solution here: http://ubuntuforums.org/showthread.php?t=382441

My take on it, posts do help find solutions, here is my contribution to try helping others find a solution quicker.

Pity the User

2007-05-05T08:27:00.000-04:00

I have recently got the opportunity to get my hands on a copy of Vista Ultimate at MS employee prices. I jumped at the opportunity and, as soon as I ensured all my crucial apps actually ran on Vista (VMWare Workstation in particular), proceeded to install it on my laptop. I spend my working hours (and others for that matter) using this laptop so, although I surely did not get to explore all the niceties of Vista, I got the daily use experience of running it. The first impression was the "Wow" that MS advertises so much. It is indeed an eye-candy-filled OS. It looks awesome and all the UI interactions have been tuned to please the eye, Windows Aero is indeed really enticing. But...the niceties of a new UI only last so much...My daily work is spent mostly on another OS environment. All my work is done on Linux and I had been used to depend on VMWare Workstation to be able to get the best of both worlds and jump around as needed. My experience with XP and VMWare Workstation had been impeccable and I could not recommend it more...Then came Vista...oh well...Suddenly my Pentium 4 3.4Ghz with Hyperthreading, 2Gb RAM started grinding to a halt. Although a year old now, this is not (I believe) a run-of-the-mill laptop...A laptop with these specs should be able to handle this OS plus the apps that I needed to run on top of it! My frustration grew when looking at memory usage on Vista...Just starting up brought me to 600Mb usage, with VMWare I was up to 1.6Gb...this on a 2Gb RAM machine...And I started looking through the nice UI and thinking seriously that I could not work daily with this...The initial "Wow" turned into "Wow, this is unbearable!". So, after some serious consideration I decided it was time to byte the bullet and wipe out my system and replace it by something more snappy that actually made good use of my hardware...Ubuntu 7.04 to the rescue! Ok, I am not religious about the OS war and am one of the people who tries to take advantage of whatever each has to offer so, being the gamer that I am, I left Vista on a dual boot setup alongside Ubuntu (I still have hopes of playing Halo 2 on Vista someday to get my achievements! ). Now I am running Linux as a first OS...my life became a lot less stressing...and I can still run Windows XP or Win 2K on a VMWare Workstation virtual host for all the testing I need to do...The best of both worlds I would say...

With this Windows Vista we are bound to see a new need to get new hardware where once what you had was just fine...and, to be honest, without any real *day to day* real important enhancements that I can see (again, I stress the *day to day*... you might do cool and important things on Vista but I'm betting these are completely irrelevant for the common user).

But I believe Ubuntu 7.04 (and Linux in general) is still not there as well...I had to jump through some serious loops to get my Wireless card and my sound card to work on my laptop...It has evolved immensely no doubts. I still remember the old Linux installations of the early nineties where you really had to be courageous and curious to even try it. But good as it is this is hardly mass user ready...

Pity the user indeed!

Unit Testing Struts 2.0 (Part 2)

2007-03-29T20:46:00.000-04:00

Edit: for latest on this see recent post.

In response to a comment made to Unit Testing Struts 2.0, here is the updated, complete code for Struts 2.0 testing. Hope this is useful. Have questions ? Want to discuss any of this ? Just drop me a line...Read on, includes support class code, small snippets for creation of Spring beans, Struts 2.0 actions, Struts 2.0 action proxies.


import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionProxy;
import com.opensymphony.xwork2.ActionProxyFactory;
import com.opensymphony.xwork2.ObjectFactory;
import com.opensymphony.xwork2.config.ConfigurationManager;
import com.opensymphony.xwork2.config.entities.ActionConfig;

import org.apache.struts2.StrutsConstants;
import org.apache.struts2.StrutsStatics;
import org.apache.struts2.config.Settings;
import org.apache.struts2.config.StrutsXmlConfigurationProvider;
import org.apache.struts2.dispatcher.Dispatcher;
import org.apache.struts2.impl.StrutsActionProxyFactory;
import org.apache.struts2.spring.StrutsSpringObjectFactory;
import org.apache.struts2.views.freemarker.FreemarkerManager;

import org.springframework.core.io.FileSystemResourceLoader;
import org.springframework.mock.web.MockServletContext;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.web.context.ConfigurableWebApplicationContext;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.XmlWebApplicationContext;

import java.lang.reflect.Method;

import java.net.URLEncoder;

import java.util.HashMap;
import java.util.Map;

import javax.servlet.ServletContext;


/**
 * Class for easier support of Struts related
 * testing. Takes care of all the configuration details
 * that allow test classes to create beans (Spring),
 * actions (Struts), intercepted actions (Struts).
 * Class is singleton to minimize hit of initializing
 * Struts and related infrastructure (e.g. Hibernate).
 *
 * @author Francisco Assis Rosa
 */
public class StrutsTestCaseSupport {

    /**
     * Singleton variable
     */
    public static StrutsTestCaseSupport _theInstance;

    /**
     * Singleton access
     */
    public static synchronized StrutsTestCaseSupport getInstance() {
        if ( _theInstance == null ) {
            _theInstance = new StrutsTestCaseSupport();
        }
        return _theInstance;
    }

    /**
     * Application context class (encapsulation of applicationContext.xml)
     */
    ConfigurableWebApplicationContext _applicationContext;

    /**
     * Configuration Manager object, to allow for encapusulation of struts.xml,
     * creation of actions and their proxied counterparts, creation of
     * servlet context from this application context
     */
    ConfigurationManager _configurationManager;

    /**
     * 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
        Settings.set(StrutsConstants.STRUTS_OBJECTFACTORY_SPRING_AUTOWIRE,"name");
        StrutsSpringObjectFactory objectFactory = new StrutsSpringObjectFactory();

        // set system object facory
        ObjectFactory.setObjectFactory(objectFactory);

        // 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.setServletContext(servletContext);
        _applicationContext.setConfigLocations(new String[] {"WEB-INF/applicationContext.xml"});
        _applicationContext.refresh();

        // initialize the object factory with the mock servlet context, application context
        objectFactory.init(servletContext);
        objectFactory.setApplicationContext(_applicationContext);

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

        // 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));
        _configurationManager.reload();
    }

    /**
     * create a servlet context useable for a specific action
     *
     * @param applicationContext the application context to use in the servlet context
     * @return 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");
        servletContext.setAttribute(FreemarkerManager.CONFIG_SERVLET_CONTEXT_KEY,null);

        // 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
     * @return the map for the action's context
     * @throws Exception on processing, configuration errors, test failure
     */
    public Map buildActionContext ( String serverName, String accessMethod, String accessUrl, Map requestParamMap )
        throws Exception {
        // 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
        request.setServerName(serverName);

        // add request parameters
        if ( "get".equals(accessMethod) ) {
            for ( String oneParamName : requestParamMap.keySet() ) {
                request.addParameter(oneParamName,requestParamMap.get(oneParamName));
            }
        } else if ( "post".equals(accessMethod) ) {
            String requestBody = "";
            for ( String oneParamName : requestParamMap.keySet() ) {
                if ( requestBody.length() > 0 ) {
                    requestBody += "&";
                }
                requestBody += oneParamName + "=" + URLEncoder.encode(requestParamMap.get(oneParamName),"UTF-8");
            }
            request.setContent(requestBody.getBytes());
        }

        // add context, request and response to an action context map
        Map actionContext = new HashMap();
        actionContext.put(StrutsStatics.SERVLET_CONTEXT,servletContext);
        actionContext.put(StrutsStatics.HTTP_REQUEST,request);
        actionContext.put(StrutsStatics.HTTP_RESPONSE,response);
        actionContext.put(ActionContext.DEV_MODE,new Boolean(false));
        // add request parameters to action context
        Map actionContextParams = new HashMap();
        for ( String oneParamName : requestParamMap.keySet() ) {
            String[] paramValue = new String[1];
            paramValue[0] = requestParamMap.get(oneParamName);
            actionContextParams.put(oneParamName,paramValue);
        }
        actionContext.put(ActionContext.PARAMETERS,actionContextParams);

        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
     * @return the object factory created bean
     * @throws Exception on processing, configuration errors, test failure
     */
    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)
     * @return the proxyed action
     * @throws Exception on processing, configuration errors, test failure
     */
    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)
     * @return the proxyed action
     * @throws Exception on processing, configuration errors, test failure
     */
    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
        actionProxy.getInvocation().getInvocationContext().setSession(sessionMap);

        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)
     * @return the properly injected action
     * @throws Exception on processing, configuration errors, test failure
     */
    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);
    }

And using it to create any bean:


        MyClass myObject = (MyClass)StrutsTestCaseSupport.getInstance().createBean("myBeanName",new HashMap());

Or to do a full fledged Struts 2.0 action proxy test:


        // create action for ActionSearchTest
        Map requestParameters = new HashMap();
        requestParameters.put("searchMode","quick");
        requestParameters.put("searchText","Testing");
        Map actionContext = StrutsTestCaseSupport.getInstance().buildActionContext("struts.assisrosa.com","get","/search/results",requestParameters);

        // create the proxy for the action, this encapsulates all
        // the interception stack up to the real action
        ActionProxy proxy = StrutsTestCaseSupport.getInstance().createActionProxy("results","/search",actionContext);

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

        // confirm result, any exception thrown will cause test to fail
        assert result.equals("success");

Or a Struts 2.0 action test (no proxy in front of it):


        MyAction myAction = (MyAction) StrutsTestCaseSupport.getInstance().createAction("hello","/site",actionContext);
        String result = myAction.execute();
        assert result.equals("myExpectedResult");

Continous Integration

2007-02-12T09:35:00.000-05:00

Continuous integration is a practice introduced by Extreme Programming (XP) that brings in the idea that developers should check in their code often and that their work should be continuously integrated and tested to ensure that no error goes unnoticed (see article by Martin Fowler). The practice is tightly integrated with the concepts of source control, unit testing and automated building as these are the privileged means of bringing the code together and running tests on it. Continuous integration (CI) not only works nicely but does enforces some pretty important habits to developers.

Developers working on a CI project will be required to use source control for their code. Sounds like a basic tool for any development project but I've seen too many projects where source control is completely absent...CI simply requires it...nice.
Developers working on a CI project will be rewarded by putting in place as many unit tests as possible. How ? By seeing that less errors will sneak by because of the existence of this safety net of testing. It is pretty cool to see that you avoid putting mistakes into production because of this first line of defense. Better our CI screaming at us than our clients right ?
Developers working on a CI project get used to the concept of automated building and the concept of building from scratch. Again, often have I seen in the past cases where code that is not rebuilt regularly from scratch becomes too entangled in dependencies that prevent it from building from a clean slate.

All these make for pretty strong points in favor of CI. And it is not that hard to put it in place...There is a significant amount of tools that joined together make for a great CI platform. Just look around. A winning combination for me, developing in Java, has been:

Cruise Control. A CI framework that glues together all the components to provide a pretty decent CI setup. From HTML reporting to email notification of success failures of builds, this is a pretty cool tool to use.
Subversion. A version control system that addresses a lot of the typical weak spots of other version control systems (e.g. CVS).
Ant. An automated build tool for Java. I doubt anyone working in Java never heard of Ant.
TestNG. A really cool testing framework for Java. Check it out...

All of the above are free tools that you can get and play with, together they make up for a pretty strong CI.

CI takes a step ahead when talking about Continuous Database Integration (CDBI). Paul Duvall at Test Early has been doing some pretty interesting presentations on it. It does bring a new level of testing to your database-driven apps. One which enforces the cooperation between developers and database administrators and builds a structure that ensures that you can deploy your application at any point in time. If you ever seen a project where to redeploy in a new system you have to go chasing for the DB schema required to deploy a clean system, you know the kind of sorrows CDBI can save you from.

I simply *guarantee you* that if you ever start using CI, you will not want to work again without it.

Javascript: The Definitive Guide

2007-02-07T21:05:00.000-05:00

The title does sound presumptuous but after reading it you can only agree that if there is any Javascript book worth reading, this is it. David Flanagan does a most excellent work of introducing the Javascript language and of exploring all the kinks and nice features that you can take from it.

Having known Javascript for sometime I could not avoid being wowed in some chapters by some cool features that I really did not know existed in the language.

This 5th edition is well worth it even if you read previous editions. I did have a previous version and found that this new edition brings a significant amount of new content worth spending your budget in.

The book is well structure dividing it's presentation in core javascript and client-side javascript. Something I really liked seeing.

The core Javascript section presents pretty successfully crucial aspects of the language like closures and prototyping (among many others)...Even if you already know Javascript you should give it a try...I'm almost sure you will learn something from it.

The client-side Javascript is where this book gets even more of its value... from a fantastic CSS reference chapter (I do not believe you need much more than this to get you rolling with CSS), to even handling, DOM navigation, XML handling and scripting with Java, Flash, charting with Javascript and CSS (way cool). A really interesting read.

Like I said before, if you're out to get just one (or your first) Javascript book, I believe this is it! An interesting and absolutely essential read for any web developer these days.

5 stars!

DNS Analysis and Debugging

2006-12-05T20:36:00.000-05:00

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.

Unit Testing Struts 2.0

2006-11-19T23:45:00.000-05:00

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
    Settings.set(StrutsConstants.STRUTS_OBJECTFACTORY_SPRING_AUTOWIRE,"name");
    StrutsSpringObjectFactory objectFactory = new StrutsSpringObjectFactory();

    // set system object facory
    ObjectFactory.setObjectFactory(objectFactory);

    // 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.setServletContext(servletContext);
    _applicationContext.setConfigLocations(new String[] {"WEB-INF/applicationContext.xml"});
    _applicationContext.refresh();

    // initialize the object factory with the mock servlet context, application context
    objectFactory.init(servletContext);
    objectFactory.setApplicationContext(_applicationContext);

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

    // 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));
    _configurationManager.reload();
}

/**
 * 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");
    servletContext.setAttribute(FreemarkerManager.CONFIG_SERVLET_CONTEXT_KEY,null);

    // 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
    request.setServerName(serverName);

    // add request parameters
    for ( String oneParamName : requestParamMap.keySet() ) {
        request.addParameter(oneParamName,requestParamMap.get(oneParamName));
    }

    // add context, request and response to an action context map
    Map actionContext = new HashMap();
    actionContext.put(StrutsStatics.SERVLET_CONTEXT,servletContext);
    actionContext.put(StrutsStatics.HTTP_REQUEST,request);
    actionContext.put(StrutsStatics.HTTP_RESPONSE,response);
    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
    actionProxy.getInvocation().getInvocationContext().setSession(sessionMap);

    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();
    requestParameters.put("param1","param1-value");
    requestParameters.put("param2","param2-value");
    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();
    requestParameters.put("param1","param1-value");
    requestParameters.put("param2","param2-value");
    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... ;-)

iPodaholic

2006-11-15T09:22:00.000-05:00

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! :-)

Tizra Blog is alive!

2006-10-13T09:45:00.000-04:00

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!

TiddlyWiki

2006-10-01T23:00:00.001-04:00

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...;-) ).

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

No Fluff Just Stuff Impressions

2006-10-01T22:59:00.000-04:00

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).

Blogger Enhancements and Tizra AgilePDF Boasting

2006-09-16T23:39:00.000-04:00

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...;-)

<shamelessPlug>

If 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.

The 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.

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.

</shamelessPlug>

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...

Computer Science Talks

2006-09-15T17:55:00.001-04:00

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...;-)

No Fluff Just Stuff

2006-07-19T10:02:00.000-04:00

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! :-)

Free books online!

2006-07-18T11:52:00.000-04:00

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.

JavaOne 2006 Sessions Online

2006-07-13T09:38:00.000-04:00

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.

Getting organized!

2006-07-12T09:35:00.000-04:00

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!

Sharing initialization across Unit Tests

2006-06-09T10:37:00.000-04:00

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...

FireBug

2006-06-07T09:42:00.000-04:00

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. :-)

Eventum Issue/Bug Tracking System

2006-05-17T14:02:00.000-04:00

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....

Java Server Faces in Action

2006-04-09T08:26:00.000-04:00

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.

Pros:

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!).

Cons:

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...

An official name!

2006-03-16T10:38:00.000-05:00

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.

New Company, New Life!

2006-03-03T11:35:00.000-05:00

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...

Lucene in action

2006-02-13T13:06:00.000-05:00

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!

JBoss EJB 3.0 TrailBlazer

2006-01-15T10:31:00.000-05:00

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

2006-01-15T09:57:00.000-05:00

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]

2006-01-15T09:43:00.000-05:00

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....

Healing my head from the bumping on the wall ?

2005-12-22T00:03:00.000-05:00

Yup...time for a pause...usual Christmas/New year's break...Will not be blogging but will be taking with me a couple of books...my "christmas break collection" will include:

Hibernate: A Developer's Notebook
Spring: A Developer's Notebook

The Developer's Notebook series is actually proving to be pretty cool....granted it does not cover all you need to know and probably implies that you already know *something* but still...worth a read...They also deviate a bit from the "standard" technical book ranging around 150 pages instead of the 500-1000 typical tech book size...would consider them to be "quick reads"... As all tech books, reading them is not enough and some "hands in the dirt" is a requirement...mine are happilly getting dirty since these are technologies that I really want to play with and grok...

Blogging should resume in 2006...Happy hollidays and happy new year!

JBoss a Developer's Notebook and JBoss at Work

2005-12-14T23:53:00.000-05:00

Two good JBoss books this time. Both seem to complement each other and should be a must read for someone wanting to learn about JBoss.

The first one is JBoss at Work: A Practical Guide. What I liked about this book can also be one of its shortcomings. The book follows a incremental development approach where concepts and technologies are introduced chapter by chapter, one step at a time. This might be a bit tedious for experience, seasoned developers who know already about the concepts being introduced. The way they are introduced however is, I believe, pretty interesting and does make up for an interesting read. I did like reading it a lot even though it was far from the first time I looked into these concepts, technologies and approaches. I would have liked to see a bit more on Entity Beans but do understand the reason why they were not approached in the book.

The second book is yet another of the Developer's Notebook series. Like clearly stated in the book, you will not end up being an expert or even getting close to knowing all there is on the subject but by the end of it you should have grasped a set of important items in a very pragmatic perspective. This is a book which is probably more recommended for developers who have already read something about JBoss otherwise some of the nice pearls in the book might get lost among the rest.

Both books are in my recommended books list!

Synch with team members off-site!

2005-11-29T23:03:00.000-05:00

If you ever had to work with team members off-site you know that it can be extremely difficult to convey ideas or to explain/discuss ideas. There are however a ton of tools that can help with that effort...In typical "Bumping my Head on the Wall" style, here is one that is working really nice for me. Microsoft Office LiveMeeting does what I need and more...I can share my apps with whoever I am talking to, can give control of those apps to the other party, etc... From the distributed development team perspective this does seem to be a very very cool and useful tool. It does solve a bit the issue of the difficulty of showing things or discussing ideas with off-site team members...Kind of gives you back that "drop by your cube" feeling. Like I said, this is far from being the single tool doing it out there...I have also used Webex in the past with also pretty good results. But if you have off-site team members you have got to have something like this in your tool bag!

Professional Apache Tomcat 5

2005-11-25T22:33:00.000-05:00

Here's a nice book I just finished reading a couple of weeks ago. Since I actually work with Tomcat I found the book to be pretty useful. I did learn about a series of items that I did not know as much as I should and would recommend without any hesitation this book to anyone wanting to know a bit more about Tomcat. It does shed some light into features of Tomcat that I had not explored before (e.g. built-in DB connection Pooling, tomcat clustering, JMX). If there is anything that I would correct about this book, it would definitely be the chapter on Tomcat+Apache integration. The book is all about mod_jk2 which is now a connection component dropped by Apache in favor of mod_jk and proxy_ajp. The examples for database connection pooling actually did not work for me, but getting the gist of it was enough to allow me to explore and figure out the right way to achieve it.

Veredict: rates pretty high on my list.

Keep your Tomcat up to date!

2005-11-17T21:46:00.000-05:00

It is definitely worth it...a 2x to 3x performance improvement between version 5.5.9 and 5.5.12...now, I would never expect that but sure enough that is the kind of performance enhancements I got when updating to this newer version....pretty impressive...Well, if you take into account that performance of 5.5.9 for my specific example was lower than a 4.0.4 version, I would say Tomcat got their act together with this new update...Bottom line: consider keeping up to date with the usual precautions!

And by the way....NetBeans 5.0 Beta 2 is out! Supposed to contain over 1,800 bug fixes from Beta 1...Since I am still pretty happy with NetBeans 5.0 I already got my NetBeans update.

WebTst 0.9.3 has been released!

2005-11-11T07:53:00.000-05:00

I finally got around churning out another release of WebTst. For this version I had some pretty important feedback to work from and was able to address some major issues in the code. WebTst 0.9.3 is now more robust than ever.

This has been my "night" project for the last month or so...I am really happy to be able to report that it has now been released. Meanwhile I still continue to use it avidly at work and at home.

WebTst is a web testing infrastructure that aims at making and maintaining system integration tests as simple as possible. It provides web interfaces for test capturing making creating tests literally as easy as browsing the web (it implements an http/https proxy for those curious), web interfaces for maintaning and enhancing capturing tests, graphical analysis tools and test suites maintenance capabilities. With it you can do monitoring, smoke, regression tests.

It has been hosted at SourceForge for quite sometime and you can check it out at http://sourceforge.net/projects/webtst/

VMWare Rocks!

2005-10-28T22:44:00.000-04:00

And it rocks really hard! Since I evaluated VMWare 5.0 I became completely hooked on it. To the point where I really can not conceive anymore (professional) life without it. I have it on my XP box running Linux Ubuntu and Windows 2000. Have played as well with other OSes with equally impressive results.

Here's an example of handy use. I was working on WebTst (topic for another post) and was faced with the problem. I had to try my code with different versions of an installed set of packages. Big pain in an typical scenario. Install set one, develop, test, once happy either deinstall set or reinstall OS, install set two, develop, test, once happy go back to set one to make sure is not broken. Of course same drill could be done with two machines with different configurations or two OSes on same machine. Paaaainfull. Enter VWMare. I simply install a fresh version of the OS, capture a snapshot, install set one of packages, take a snapshot, test, develop, once happy, revert to clean install snapshot, install set two of packages, test, develop, once happy can freely jump between snapshots with package set one or two....no more installs for me...

Now *that* is pretty nice!

It's uses do not stop here, from different combos of browsers and plugins to different configurations altogether....

Now get this one: you can actually setup a server (e.g. Linux) running a database, with a server running in there (e.g. Tomcat running). Take a snapshot of this state. Mess whatever you want....even power off....once you revert to previous snapshot, you will be brought to the *exact* same state that you had when you took the snapshot....database state, servers running and all...again...pretty impressive...

The list goes on and on and on....

My (professional) life *did* change with it!

(My personal life not so much...VMWare still does not change diapers at 3:00 AM or does dishes...I'm hoping for version 6.0....)

Microsoft PDC 2005 Videos

2005-10-28T21:10:00.000-04:00

Microsoft's PDC 2005 videos are available online at http://www.sys-con.tv/read/category/1238.htm. Lots of content available.

I have no prejudice against Microsoft technologies. I do believe the principle
of "each tool for it's job". Microsoft technologies do have its place and its use
and the latest .NET platform, languages and tools are way too cool! Just check
them out for a bit and let me know if you agree....

JavaOne Sessions, Java Posse Podcast

2005-10-28T16:27:00.000-04:00

Yup. They can be found online at http://developers.sun.com/learning/javaoneonline/.
Worth taking a look....Found about their existence while listening to a Java Posse podcast.

Java Posse is the successor to the now dead JavaCast podcasts. Pretty interesting podcasts filled with Java news, reviews, tech discussions and experience sharing. This is a fundamental item on my iPod.

Experiments in Load Balancing and High Availability (Part 2)

2005-10-26T00:52:00.000-04:00

The Architecture

<disclaimer>
Let me start by saying that this was just one possible solution...As I investigated and played with this a ton of other possible solutions popped up. This is just one solution I liked putting in place and that worked fine for me.
</disclaimer>

The following picture illustrates what I was trying to achieve:

The basic infrastructure and functional elements:

A firewall to isolate the internal network from the outside. In my testing, achieved by my trusty router with built-in simple firewall.
One main load balancer server. Responsible for picking up requests from end-users and directing to server machines available in the defined cluster of servers. Equipped with two network cards.
One backup load balancer server. Responsible for monitoring the main load balancer server and picking up for him in case of main load balancer server failure. Equipped with two network cards.
A cluster of servers ready to receive requests from the load balancer and ready to do the serious work to fulfill the requests and get the responses.
An internal network connecting all machines. In my testing, my five machines (would like to see this number grow!).
A dedicated network between main and backup load balancing servers to allow for more reliable and fast monitoring of load balancing servers.

The interactions:

A request coming from a user should come via the firewall (router) to the main load balancer
The main load balancer should then send over the request based on a configured heuristic to the appropriate server in the cluster.
The selected server should fulfill the request and send the request to the end-user.
The main load balancers constantly monitors the cluster to remove failed servers or add new added servers.
The backup load balancer server constantly monitors the main load balancer server to ensure that it is working, taking over the load balancing function if main load balancer server is detected to be down.

Redundancy of services is therefore present both at the server level and at the load balancing solution level. We should in this way achieve load balancing and high availability.

More to follow in the next parts on this subject:

Solutions for Load Balancing Layer, where some possible solutions are discussed, one in particular is presented in detail.
Worker Server Clustering, where a solution to a particular problem is presented.
Remaining issues

Experiments in Load Balancing and High Availability (Part 1)

2005-10-18T10:33:00.000-04:00

Part 1: The issue

The questions have always been in the back of my mind "What if my site is just too overloaded ? What if it crashes ?"....not that it matters that much to my personal sites...It's not like I have millions of users.....or that the world economy would fall over if my personal sites were down or just too slow...But still....I always felt the urge to play with solutions to overcome any performance and availability issues with my sites (but I will not stop playing Halo to make my site more performing..not that!!!). So I started my investigation on the subject....What could I put in place to provide me load balancing and high availability on a site ? I bumped, not surprisingly, into a ton of solutions...From dedicated hardware to complex software solutions. But....this being kind of "I want to explore it" experience and since I am not really not into throwing a ton of money into the experience, my aim was directed into trying to make the best of the cheapest solution possible. And there began my quest...

I was very close to getting a cheap BIG-IP. But most of what I could find on eBay was typically locked out systems or incomplete systems. Other solutions outside eBay were just outrageously expensive. For my pocket anyway. So....off with the hardware box solution...next!

I then bumped into a pretty interesting project called Ultra Monkey. I started having hope finally that I might be onto something. I jumped again onto eBay and got me an extremely expensive set of hardware (yeah sure!)...Two Pentium III 500Mhz for the much more agreeable price of $80 for both...Armed with those two and with my two other more decent computers, a Pentium 4 2.6 Ghz and a Pentium 4 2.8 Ghz, I started then to elaborate on an realistic, usable architecture to make load balancing and high availability possible on a short budget.

Plans taking shape...Ultra Monkey doing the management of my application, I started to think about issues like back-end application distribution and synchronization. With my first goal being to get to a solution for a Java Web application I looked a bit more into books on Tomcat...and eventually found the way to implement Tomcat clustering behind any load balancing and high availability solution. That led me to the final piece of this puzzle. I now have a solution that convinces me that I can put load balancing and high availability in place....Working on my personal sites...my site users probably could not care less, but I now can finally put it to rest....

More to follow in the next parts on this subject:

Overall architecture
Solutions for Load Balancing Layer
Tomcat Clustering
Remaining issues

NetBeans 5.0 Beta

2005-10-14T23:22:00.000-04:00

I have been looking at Eclipse for quite sometime but was never quite convinced by it (let the flames start). Seemed awkward to use and most of the functionality was not where I expected it to be. In addition to that, handling of pre-existing projects with rich, complex ant files seemed hard to say the least....Enter NetBeans 5.0...Using it with pre-existing projects has been a breeze...For starters there is right out-of-the-box a "create a project from ant file" which creates a project that not only gets bootstrapped from the ant file but keeps control in the ant file. Builds can still happen via the existing ant file with nice integration between the IDE and the ant file. All functionality is right where I would expect it to be making my life a lot easier and reducing immensely the effort of getting into a new tool.

As if that was not enough (for me at least), there are a ton of new features in NetBeans 5.0 which make it worthy to invest some time to evaluate. Matisse -- a WYSIWYG dialog editor, code completion, tighter CVS integration, tighter JUnit integration, support for Ant file debugging (how cool is that?!?!?), JBoss support (among others, I happen to be more interested in JBoss), deployment descriptor editors, easier plug-in development, AJAX solutions....and the list goes on.

If you do not want much time looking at the IDE itself, you can at least watch a small presentation on it:

http://www.javalobby.org/eps/netbeans5/

And new features are supposed to be coming in later after the final launch. As far as I'm concerned, this IDE works pretty nicely for me. Move over Eclipse, here's NetBeans 5.0.

Bumping my head on the wall

2005-10-14T14:17:00.000-04:00

Yup. For anyone working in software development, sometimes it sure feels like bumping my head on the wall. Traps and pitfalls, tips and tricks, new tools, new processes, cool books, cool technologies, interesting and useful links. I'll keep adding them here.

If you have any comments or feedback, send them along!