The V N Albuquerque Blog

Messaging With WebSphere MQ Using Spring JMS

2011-03-15T08:06:00.012Z

Spring JMS provides a simple API to work with JMS implementations. This post describes how to use Spring JMS to communicate with IBM WebSphere MQ. The code has been tested with WebSphere MQ version 7.0.1. Maven is used as the build tool. It is also used to resolve the WebSphere MQ and other dependencies. Only relevant code snippets are listed below - for the complete source, please refer to the link at the bottom of this post.

To start off we need to obtain the WebSphere MQ JARs. These JARs are proprietary - hence they will not resolve through a public Maven repository like Maven Central. These JARs need to be obtained from the WebSphere MQ installation directory and manually deployed to our local Maven repository. The config below defines the WebSphere MQ dependencies in our Maven POM file.

Spring's JMSTemplate class is the key to simplifying access to the conventional JMS API. It abstracts the common and repetitive boiler-plate code by handling the creation and closing of connections and sessions, sending and receiving of messages and handling of exceptions. JMSTemplate and a few other beans need to be defined in our Spring config.

MQQueueConnectionFactory defines the connection to the Queue Manager. Next we define SingleConnectionFactory102, DynamicDestinationResolver and finally JmsTemplate102. The 102 suffix implies that our underlying JMS implementation version is 1.0.2. Now that our configuration is complete, we can send and receive JMS messages.

To send a JMS message, we use the send(String destinationName, MessageCreator creator) method of JMSTemplate.

To receive a message, we use the receive(String destinationName) method.

As we can see, Spring's JMSTemplate really simplifies and speeds-up connecting to a JMS provider like WebSphere MQ.

Sample Source Code

A fully functional example Maven application accompanies this post. It provides the complete source code mentioned in this post. It can be downloaded at GitHub using the link below.

https://github.com/albuquerquev/springjms_wmq

Trakko - Logging for Everyone

2009-07-18T00:52:00.011+01:00

Today I am pleased to announce the launch of Trakko, a personal project that I have been working on over the past few months. Trakko is an online general purpose logging application enabling users to log events in a central location. Every entry has a date and can be tagged to enable grouping of related entries. Trakko also supports exporting entries to a spreadsheet for reporting purposes.

Trakko was concieved entierly on a need basis and developed during weekends and my spare time. Over the years, I used a number of different ways to log events that I wanted to remember - text files, spreadsheets etc. I then developed a database application that I used personally. After regular use, I was certain that this application would be useful to a broad range of users who wish to keep track of events that are important to them. This led to the launch of Trakko.

Trakko has been built entirely on an open source stack. MySQL, Spring, Hibernate, jQuery and a number of other open source technologies power Trakko.

If you feel the need to do some logging, try out Trakko and make sure you leave some feedback.

Live and Die with jQuery

2009-01-19T14:35:00.019Z

jQuery is a JavaScript library that makes web programming simple and highly productive. With the new 1.3 release, jQuery now supports live and die events. To understand live and die events, we must recollect how things were done before the 1.3 release. To bind events to elements we used jQuery's bind method.

$("input:type=button").bind("click", function() {
    alert($(this).val());
});

The code above binds the click event to all buttons on the page. However, there is one major drawback to using the bind method. Any buttons dynamically added to the page in the future must be individually bound with the click event. Hence, bind only works on the set of elements currently in the DOM.

live overcomes this drawback and binds to elements currently present and also ones added in the future. The syntax for live is similar to bind. The code below binds the click event to all buttons currently on the page and even ones added in the future.

$("input:type=button").live("click", function() {
   alert($(this).val());
});

die is the opposite of live. To unbind all events previously bound with live we use the die method.

$("input:type=button").die("click");

Advanced Filtering in GMail

2008-04-09T17:06:00.004+01:00

GMail provides filters and labels that are an effective way to organize and access the huge number of emails that we receive everyday.

Recently I came across another feature of GMail that takes filtering of email to a whole new level. Every GMail address can be suffixed with a + followed by some text. E.g. john@gmail.com can be aliased as john+family@gmail.com, john+facebook@gmail.com or john+cv@gmail.com. All of the aliased mail gets sent to the primary account (john@gmail.com). This opens up whole new possibilities for powerful filtering.

Take for example the email address you provide on your CV or at a job search website. At times when you are actively looking for a new job, these emails are highly important. During other times, you might not want your Inbox to be cluttered with job notifications. This can be easily handled using GMail email aliases. Simply provide john+cv@gmail.com (or john+123@gmail.com if you wish to be discrete) when signing up at a job search website and on your CV. Next setup a GMail filter that looks for emails sent to john+cv@gmail.com and either flags them for your attention or at other times automatically deletes them!

Email rules and filters have existed for a long time but GMail aliases take this to a whole new level. The possibilities (of email suffixes) are indeed endless!

Apache Ivy

2008-03-20T16:45:00.005Z

Almost all Java projects, apart from the most trivial ones have dependencies. These dependencies could either be on other projects or third-party libraries. Managing these dependencies can be extremely time-consuming and distracting from the primary focus of the project. Apache Ivy is a tool for managing library dependencies. Ivy neatly fills the gap by providing an easily configurable and automated dependency management system. Further, Ivy supports transitive dependencies management. Hence all we need to do is declare our main dependencies and Ivy automatically fetches all the sub dependencies along with the main dependencies from a public location such as the Maven 2 repository.

Installation

Ivy is designed to work with Ant, wherein Ant is used to run the build tasks and Ivy is used to resolve, retrieve and manage the dependencies. The simplest way to get started is to copy the Ivy jar file to the Ant lib (ANT_HOME/lib) directory.

Configure ivy.xml

The ivy.xml configuration file is the main file that is used to describe our dependencies. Below is an example of a configuration file that states two main dependencies, Hibernate and the C3P0 library.

<ivy-module version="2.0">
    <info organisation="techvj" module="ivy-test" />
    <dependencies>
        <dependency org="org.hibernate" name="hibernate" rev="3.2.6.ga" />
        <dependency org="c3p0" name="c3p0" rev="0.9.1.2" />
    </dependencies>
</ivy-module>

Integrate With Ant

The final step is to integrate the Ivy dependency resolution process with our Ant build process. Following is an example of a build.xml file with the retrieve task defined:

<project xmlns:ivy="antlib:org.apache.ivy.ant" name="hello-ivy" default="retrieve">
    ...
    <target name="retrieve" description="">
        <ivy:retrieve />
    </target>
</project>

On running the above Ant build, Ivy retrieves the Hibernate and C3P0 libraries and all of their dependencies to the local machine. The retrieved libraries are stored in a cache and not downloaded again on successive invocations. Apache Ivy is a great tool in a Java developer's toolbox for managing library dependencies.

Wicked Shell for Eclipse

2008-03-19T12:55:00.002Z

An Eclipse plug-in that I have begun to regularly use is Wicked Shell. Wicked Shell provides direct access to the operating system's shell (Cmd, Bash, SH etc.). In fact it is not an actual shell, it only acts as a window to the underlying shell using a SWT text widget to transfer commands and display output. The result is having an Eclipse view that behaves as a shell.

As with any Eclipse view that is regularly accessed, I would suggest setting up a shortcut key binding for Wicked Shell. On my installation I chose Alt+Shift+Q, S as the combination did not conflict with other pre-set bindings.

Perfect Paper Passwords - Two-Factor Authentication for the Masses

2007-11-12T17:04:00.000Z

Usernames and passwords have long been established as the de facto form of authentication for websites and other systems. They provide a convenient system for authenticating and identifying users. However, they are also highly vulnerable to dictionary attacks, weak passwords, key-loggers etc. Recently, two-factor authentication has been suggested as providing a much stronger approach. In addition to 'Something You Know', such as a password, you also provide 'Something You Have', such as a security token. Verisign and RSA Security offer such products that produce a time-synchronized sequence of digits that change at regular intervals. Systems that incorporate these security token mechanisms, accept the sequence of digits in addition to a password during authentication.

Steve Gibson from GRC recently released a similar system based on passcodes. The Perfect Paper Passwords system produces a set of one-time passcodes. The passcodes are created using a 256-bit Sequence Key passed through a Rijndael/AES Cipher. The passcodes are then grouped into credit card sized passcards across 7 columns and 10 rows. During authentication, the system would prompt the user to enter the passcode at a particular column-row location (e.g. A3, D8 etc.). Since the passcards can be printed on paper it is an inexpensive, simple and highly-effective method of providing two-factor authentication.

The system has been released freely for public use and there are a number of language specific implementations already in place. Based on the sheer number of possible combinations, the PPP system is 16.77 times more secure than the token based systems by Verisign and RSA Security!

Quick Access in Eclipse

2007-11-02T10:57:00.002Z

Any software developer using an IDE begins to truly appreciate keyboard shortcut keys to make the coding process more seamless. Eclipse has a rich set of keyboard shortcuts for almost every task and view. Ctrl+Shift+L produces a list of all available keyboard shortcuts. Remembering these key combinations for regular tasks is fairly simple, however we often recollect the task to be performed or the view to be opened without knowing the keys to be pressed.

Eclipse 3.3 M7 introduced a new feature called Quick Access (Ctrl+3). With Quick Access, UI elements such as commands, views, wizards, preference pages etc. can be quickly listed and filtered through. Ctrl+3 or Window -> Navigation -> Quick Access from the menu brings up the Quick Access dialog. On typing in the filter field, the list dynamically filters to display relevant matches. Using the arrow keys, the desired option can be selected and executed.

The next time Quick Access is opened, previous choices made will be remembered and initially displayed. Further, the filter automatically lists previous choices made across different key sequences at the top. Quick Access has now become my Swiss Army Knife while using Eclipse for development.

Best of Open Source in Platforms and Middleware

2007-09-28T15:41:00.000+01:00

Being a software developer, I have truly begun to appreciate the benefits that my organization receives from Open Source software. This is especially true of middleware which consists of the meat of our IT infrastructure. Right from our Java EE application servers to our Web Services stack, the choice and quality of middleware available is truly phenomenal.

Infoworld recently announced the 2007 BOSSIE Awards for the Best of open source in platforms and middleware. I was glad to see JBoss and MySQL picking up awards - two products that I use every single day.

Project Blackbox

2007-09-09T15:55:00.001+01:00

Project Blackbox was launched around a year ago by Sun Microsystems. It is promoted as a mobile data center built into a 20' shipping container. The goal behind Project Blackbox is to provide a significantly powerful and capable data center that can be easily configured and deployed to varied and extreme locations. It is an interesting product and can be seen to fit into a number of scenarios where a traditional brick-and-mortar data center would not be feasible.

The Project Blackbox website has interesting information on the product. The video of the Earthquake Test of magnitude 6.7 is particularly impressive. I hope to soon spot black shipping containers with the Sun logo on rooftops all over our city.

Memory Monitoring on Security Now

2007-08-12T12:40:00.000+01:00

Security Now is a weekly podcast that focuses on the topic of computer security. I am a regular listener to the show and received a rather pleasant surprise to find a question that I had posted to the podcast being discussed.

I often like to track usage of memory (RAM) on my Windows machine. The tool that I usually use is the built-in Process List monitor (activated using Ctrl-Alt-Del). However, I was wondering if there was a more user-friendly app, possibly with a graphical view displaying memory usage by applications and processes. Hence I posted the question to Security Now. Below is the transcript of the question being discussed by Steve Gibson and Leo Laporte on Security Now Episode 104.

...

LEO: That’s the problem is that it’s all, you know, it’s international. You know, it’s tough because we’re an international podcast. For instance, Vijay Albuquerque in London - or it could be Vijay London in Albuquerque, doesn’t matter - now has plenty of room on his drive. He says: Dear Steve and Leo, after hearing about SpaceMonger, which by the way, Steve, I’ve been recommending everywhere, the original free version...

STEVE: Yup, it’s so nice.

LEO: I just recommended it on the radio show last weekend. He says: I’ve reclaimed virtually gigabytes of data from my hard drive. It gives you a visual display of what’s wasting space on your hard drive, makes it easier to get rid of it. He says: Is there something for memory, for RAM? He’s using the process monitor. You hit Ctrl-Alt-Del to get the Task Manager, and then you can click Processes and see the list of processes. But there must be a simpler, friendlier tool out there, something like SpaceMonger for RAM. I like it.

STEVE: RAM Monger or something, yeah. Well, it was an interesting question, so I wanted to explain that, you know, RAM is an entirely different animal than hard drive space because it is inherently dynamic. So applications which are running will use differing amounts of RAM, but there’s really no way to tell an application to stop using that much memory unless it’s a sloppy application that, for example, you could have a photo editing program where you edit a big photo which takes up a whole bunch of memory, and then when you close that photo it doesn’t release the memory, for example. So it’s possible that you could have apps which are misbehaving and essentially leaking memory.

But thankfully all Windows versions for the last decade have cleaned up the so-called "resource leaks" when the application terminates and freed up anything, any resources that they had allocated. So really just terminating processes, if you can, that is, if you don’t need them around, that are using up a lot of memory, will release their memory. But there isn’t anything that you could run to really clean up memory. There are some sort of hokey programs that are supposed to optimize your RAM. But they’ve really got a bad reputation. And really just, if you have this problem, just restarting Windows and getting things going again is the way to clear everything out.

LEO: In the old days of Windows 95, 98, and ME, the memory manager was pretty pathetic, and so you would have fragmentation of RAM, and you’d have some issues. But XP’s memory manager is fine, and there’s no point in compacting RAM.

STEVE: Right, right.

LEO: I think the memory manager does a pretty good job of getting rid of unused blocks. It can’t solve a memory leak, but nothing can solve it. If the operating system won’t get rid of that block, you know, release the block, no program’s going to come along and do it. So...

STEVE: Right.

...

Lambda Probe - Manage Tomcat with Simplicity

2007-07-24T16:10:00.000+01:00

Apache Tomcat is arguably the most popular servlet container in use today. It has a well-established user base and is usually one of the first to implement new Servlet and JSP JSR specifications. Tomcat comes bundled with the Manager App that allows to perform management tasks such as deployment, reloading etc. of webapps and other related services. The Manager App also provides an interface for integration with Ant and in the future there are plans to also provide a web service interface. The browser-based interface is functional but seems a little lacking especially for monitoring the Tomcat and JVM runtime. This space has been neatly filled by an open source project called Lambda Probe. Lambda Probe installs as just another web application under Tomcat and provides a clean, simple visual interface for core administration and monitoring.

Along with performing the usual tasks such as listing, deploying, reloading and un-deploying webapps, Lambda Probe provides comprehensive system monitoring information, JMX integration to monitor memory usage, connector stats for HTTP requests made and clustering information. Another useful feature is browsing the Tomcat log files which can be tailed in real time. Lambda Probe also provides an Availability Quick Check. Quick check is an instant way of checking the availability of the Tomcat server against three primary parameters: data source availability, free memory availability and file creation capability.

Displaying Javadocs in Subversion

2007-06-14T14:54:00.000+01:00

Javadocs are an essential component of any Java project. It is a convenient way for a developer to gain an understanding of the API and the prescribed ways to use it. This is especially true when hosting open source projects on Google Code or Sourceforge. Subversion is increasingly used as a revision control system to host source code and other project related artifacts. Google Code uses Subversion exclusively while Sourceforge provides it as an option. At times, for the convenience of hosting and to centralize resources it may be required to host the Javadocs in Subversion and access them via a browser. When using Eclipse as the IDE, connecting to a Subversion server is simple through the Subclipse plugin.

On successfully committing the Javadocs to the server and viewing the exported pages through a browser, we notice that the pages display in text and are not rendered as normal HTML pages by the browser (Screenshot). The reason behind this is that the MIME type for the pages is set to text/plain and must be changed to text/html. This can be achieved through the Eclipse UI by applying the MIME type to the svn:mime-type property on the root directory of the Javadocs. The Set property recursively option must be checked to ensure that all the pages under subdirectories are also updated with the correct type.

The last change is to update the MIME type of stylesheet.css to text/css. The Javadocs in Subversion can now be viewed successfully through a browser (Screenshot).

URLPing - A Java Utility to Ping a URL

2007-06-05T16:38:00.000+01:00

Recently there was a need at work to programmatically check the status of a URL. The requirement was to test if a specified URL returned a HTTP Status Code 200 OK or otherwise. URLPing, the utility that I wrote has been hosted on Google Code and is available for download and reuse. The utility uses the Apache Jakarta Commons HttpClient component.

URLPing is the main class. This class provides two methods ping(String url) and ping(String url, int timeout). The first method accepts a URL to ping and defaults to a timeout of 30 seconds. The second method accepts a timeout interval in seconds in addition to the URL to ping.

URLPing urlPing = new URLPing();
PingResponse pingResponse = urlPing.ping("http://www.techvj.com");
        
assertEquals(pingResponse.getResponseStatus(), ResponseStatus.OKAY);

The response to the ping method is a PingReponse object. This contains a ResponseStatus enum with values of either OKAY, ERROR or TIMEOUT depending on the outcome of the ping. It also contains a responseCode property which contains the response code of the HTTP request.

Google Calendar Error Page

2007-06-05T10:29:00.000+01:00

Don't come across Google products crashing very often, however this morning my Google Calendar instance crashed with a 'Server Error'. Well, Google Calendar is still in Beta and this is the first time it has crashed on me. I found the error page very interesting. It contained the same error message in 18 languages! Now that denotes an app with true internationalization...

Long-running Processes with Spring DAO and Hibernate

2007-04-26T14:26:00.001+01:00

Spring and Hibernate are increasingly used together in Java web applications. Spring is used as the MVC and dependency-injection framework and also provides support for data access, transaction management etc. Hibernate is usually used alongside Spring as the object-relational mapping framework. Spring's support for Hibernate is impressive through it's DAO templating mechanism. This truly simplifies matters as all the routine infrastructure plumbing code is taken care of by Spring.

Spring intercepts requests made to the webapp and through dependency-injection makes objects available in order to fulfil the request. This includes creating the Hibernate Session object used by the DAOs. The Session object is lightweight and created and destroyed for every request. Hibernate sessions are not threadsafe and should be used by only one thread at a time. In order to keep the session open throughout the lifetime of a request we tie it to the view. This is done either by using Spring's OpenSessionInViewInterceptor or OpenSessionInViewFilter as below:

<bean id="openSessionInViewInterceptor" 
    class="org.springframework.orm.hibernate3.support.OpenSessionInViewInterceptor">
    <property name="sessionFactory" ref="sessionFactory" />
    <property name="flushModeName" value="Flush_AUTO" />
</bean>

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
    <property name="dataSource" ref="dataSource" />
    ...
</bean>

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
    ...
</bean>

Most requests are synchronous and completed before the response is returned to the client. However, in the case of long-running processes, a new thread is created for execution of the process. The response is returned back to the client and the process runs independently on the server. Hibernate sessions obtained through OpenSessionInViewInterceptor are no longer available to the process as they are closed once the view has returned. This throws a LazyInitializationException complaining that the owning session was closed.

The problem can be overcome by directly accessing the Hibernate SessionFactory bean and binding the session to the long-running process thread. Hence the session is available and open within the thread itself. The UML diagram below describes our objects.

TestController is the Controller class that handles the request. Since it implements the ServletContextAware interface, Spring automatically passes the ServletContext object to it. This is used to obtain the ApplicationContext object. Next we create an instance of our LongProcessInvoker class, pass ApplicationContext to it and finally start execution using an Executor.

// TestController.java
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) {
    try {
        ApplicationContext ac = 
            WebApplicationContextUtils.getRequiredWebApplicationContext(servletContext);
            
        LongProcessInvoker lpi = new LongProcessInvoker();
        lpi.setApplicationContext(ac);
            
        Executor ex = Executors.newSingleThreadExecutor();
        ex.execute(lpi);
    }
    catch(...) {
        ...
    }
}

In LongProcessInvoker we obtain the Session using SessionFactoryUtils and bind it to the current thread. Next the long running process is invoked and once complete we execute some clean-up code by releasing and closing the Session.

// LongProcessInvoker.java
public void run() {
    try {
        // Bind session object. 
        SessionFactory sessionFactory = 
            (SessionFactory) applicationContext.getBean("sessionFactory");
        Session session = SessionFactoryUtils.getSession(sessionFactory, true);
        TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(session));        
        
        LongProcess lp = (LongProcess) applicationContext.getBean("longProcess");
        lp.runLongProcess();
        
        // Release session object.
        session.flush();
        TransactionSynchronizationManager.unbindResource(sessionFactory);
        SessionFactoryUtils.closeSession(session);
    }
    catch(...) {
        ...
    }
}

Using the above approach, we can now run long-running processes by obtaining the Hibernate session outside the view.

Loading Log4j Properties in Webapps on Tomcat

2007-04-12T21:31:00.000+01:00

Log4j is a well established and widely used logging framework for the Java platform. At the core of Log4j lies a configuration file that allows to finely configure the logging requirements for an application. Currently, the configuration file is either a XML or Java properties file. The documentation states that this configuration file should be present in the classpath of the application. This works fine for most situations however causes problems within webapps on Tomcat.

The Log4j FAQ describes this due the way in which JavaEE and Servlet containers utilize Java's class loading system.

The problem can be overcome by using Log4j's PropertyConfigurator. PropertyConfigurator enables to statically load the configuration from an external file. Using the configure(String configFilename) method we can manually specify the path to the properties file within the webapp. We can tie this code into a ServletContextListener's contextInitialized(ServletContextEvent sce) event to force the properties file to be loaded at webapp startup.
Our ServletContextListener implementation is listed below:

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import org.apache.log4j.PropertyConfigurator;

public class ServletContextListenerImpl implements ServletContextListener {
    public void contextDestroyed(ServletContextEvent sce) {

    }

    public void contextInitialized(ServletContextEvent sce) {
        String path="WEB-INF/classes/log4j.properties";
        ServletContext context = sce.getServletContext();
        PropertyConfigurator.configure(context.getRealPath(path));
    }
}

Our Log4j properties file should now be successfully loaded when the webapp is initialized.

Secure Email Attachments with TrueCrypt

2007-03-30T10:29:00.001+01:00

Digital documents have finally come of age. We now increasingly receive our bank statements, insurance quotes and receipts as digital files such as Word or PDF. Also, there is often a need to attach these documents to an email. Securing these attachments in transit over the Internet is an immediate concern. There are a number of solutions available such as Hushmail, a secure free email provider and PGP Desktop Email, a commercial email encryption product. The solution that I discuss here is based on a free, open-source encryption software called Truecrypt.

Truecrypt makes using bullet-proof encryption really easy through the concept of virtual encrypted disks. Each disk is stored as a single encrypted file and can be mounted as a real disk. Once mounted, it can be used as a local drive on the system. Entire hard-drives or USB memory sticks can be encrypted as well. Volumes can be protected using a password or through key files. Any file on the system can be used as a key file as an alternative or in addition to using a password. The key file or sequence of key files is required to encrypt and decrypt the disk.

The concept of key files makes using Truecrypt really valuable while sending sensitive attachments over email. In addition to using a password, if the sender and the receiver agree on a common file or a sequence of files that are uniquely present on both systems such as digital photographs or video clips, the encryption can be made highly secure. Hence the encrypted attachments are useless if intercepted during transit without the key files.

Truecrypt is extremely simple to use and hence there is just no excuse for not securing confidential files on storage or in transit.

Windows Vista - Features Under the Hood

2006-11-18T14:21:00.000Z

Windows Vista introduces some promising new features that aim to take desktop computing to the next level. Apart from all the eye-candy that is provided by the new Aero interface, gadgets and flip effects, there are some pretty neat features on offer under the hood. Some of these add improvements to the performance, security and productivity of the system.

Below are some of the features that I am really looking forward to in Vista.

ReadyBoost
Memory is usually one of the bottlenecks that affects system performance. As applications and background processes like anti-virus scans and drive indexing run concurrently, processor cycles and memory space are increasingly consumed. The result can be a drastic degradation in system performance. It would be great if memory could be added on the fly, providing extra space to ease the burden. Vista's ReadyBoost does just that.

With ReadyBoost, a USB memory drive with at least 512 MB of space can be plugged into the system and used by Vista as memory. The drive can be plugged out at any time without affecting or corrupting the system. Even more, all data on the drive is encrypted and hence is of no use to a malicious attack. With 2GB+ memory drives available today, this seems like a very promising technology.

BitLocker
Security of data is a primary concern these days to businesses and individuals alike. Regular reports of data theft, especially from notebook computers being stolen fuels our concerns. BitLocker is a technology that adds real-time data encryption to the Operating System volume. Hence lost or decommissioned computers are protected from data theft.

BitLocker which is available in the higher-end versions of Vista has some system prerequisites. A TPM (Trusted Platform Module), a cryptographic hardware chip needs to be present in the system. In the absence of a TPM, a USB stick that contains a startup key must be inserted at boot time.

ReadyDrive
Another new feature that exploits the latest developments in hardware is ReadyDrive. ReadyDrive makes use of hybrid hard drives, the latest hard drives that integrate non-volatile flash memory with traditional drives. This helps Windows to boot faster, resume from hibernation quicker and save on battery power. Finally the long wait for the boot process will be rather short!

100% CPU!

2006-11-07T13:19:00.000Z

I have been doing some heavy-duty image processing on my computer at work this morning and it's pushing my machine to the max! Looking at the performance graph, I was amazed to see my CPU crunching away going steadily at 100%. Looks like it's time to convince my boss to get me one of those shiny new quad-core chips from Intel...

Backup for a Rainy Day!

2006-09-26T16:01:00.000+01:00

We all know that backups are important! However, most users realize the importance of backups only after lightning strikes. We need to protect our data from the usual suspects such as hard disk crashes, fire, floods, theft etc. I have been using a free tool from Microsoft called SyncToy that makes running backups an ease. This post describes the backup procedure using SyncToy.

Note: Windows XP Professional comes with an out-of-the-box Backup utility. This utility produces a single backup file (.bkf) that could be later used to restore data and system settings. I prefer using SyncToy as it creates an exact replica of the directory and file structure. Thus the backed-up copy can also be used as a read-only reference when away from the source computer.

Steps to Getting Backups Up and Running 1. Centrally arrange data for easy backups. 2. Get an external USB hard drive. 3. Download and install Microsoft SyncToy. 4. Run SyncToy to backup your data. 5. Create a backup schedule. 6. Store the external hard drive safely.

1. Centrally arrange data for easy backups.
The first thing to do is to arrange our data centrally, preferably in a single hard drive partition or folder to facilitate easy backups.

2. Get an external USB hard drive.
There are a number of options available to store backed up data. These range from CD-Rs, DVD-Rs, USB sticks, external USB hard drives, SAN drives etc. I personally prefer USB hard drives as they are fairly inexpensive, easy to use, mobile and have significant storage capacities.

3. Download and install Microsoft SyncToy.
Once installed, setting up a backup job is pretty straightforward. Start by creating a 'New Folder Pair' (Screenshot). After specifying the source and destination folders we need to specify the synchronization action. This needs to be 'Echo' in our case (Screenshot). Using Echo, new and updated files are copied across and renames and deletes are repeated on the backup. One point to note is that Echo does not delete directories on the backup. Our backup job is now ready to run!

4. Run SyncToy to backup your data.
Running the SyncToy backup is an easy process. Select the relevent folder pair from the list at the left side of the main window and then click 'Run' (Screenshot). A progress bar apprears showing the advancement of the process.

5. Create a backup schedule.
Backups are valuable only when they are run regularly! We can automate this process by creating a Scheduled Task in Windows. This can be accessed at Start -> All Programs -> Accessories -> System Tools -> Scheduled Tasks. The wizard is simple to follow (Screenshot). To run our backup job, add -R "<folder-pair_name>" to the end of the Run command. To run all folder pairs just add -R.

6. Store the external hard drive safely.
Once we have a backup schedule in place it makes sense to store the backup drive at a separate geographic location to the source. This proves essential in times of natural calamities such as fire, floods, theft etc.

Thanks to SyncToy we now have a backup procedure in place!

Spring MVC and AJAX with JSON

2006-09-13T14:06:00.001+01:00

One of the main decisions to be taken while developing AJAX applications is the format of messages passed by the server to the client browser. There are many options to choose from including plain text, XML, CSV etc. One of the more popular choices today is the JavaScript Object Notation (JSON). JSON provides a nice name-value pair data format that is easy to generate and parse. This is especially true when using an AJAX toolkit like Dojo that provides built-in functionality to parse JSON messages at the client. If you are using Spring MVC as your web framework, generation of these JSON messages is very straight-forward as well. Below we understand how to produce JSON messages while using Spring MVC.

Spring MVC defines the View interface to render views to the client. The framework provides a number of implementations including JstlView, RedirectView, TilesView etc. In order to return JSON messages we implement the View interface to create a new class that returns data formatted using the JSON notation. We shall call this class JSONView.

The method that we need to implement is render(Map model, HttpServletRequest request, HttpServletResponse response). The render method accepts a Map as it's first parameter and produces the output. We could manually iterate through the Map, process and produce the JSON output. However, there is a Java library called JSON-lib that produces the JSON notation. The code below shows our JSONView class that can be used as a Spring MVC View to return JSON output to the client.

import java.io.PrintWriter;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import net.sf.json.JSONObject;
import org.springframework.web.servlet.View;
 
public class JSONView implements View {
    public void render(Map map, HttpServletRequest request,
    HttpServletResponse response) throws Exception {
        JSONObject jsonObject = JSONObject.fromMap(map);
        PrintWriter writer = response.getWriter();
        writer.write(jsonObject.toString());
    }
 
    ...
}

As can be seen from the code above, Spring exploits MVC to it's full potential and provides the flexibility to tailor the view to exactly suit our needs.

Hello World!

2006-09-09T10:37:00.000+01:00

Hello World! Well, I finally had to bite the bullet and start my very own blog. Starting off with modest ambitions, I primarily hope to blog about my experiences with software, programming, technology and also general topics that I find interesting…

I am a software developer by profession, primarily focusing on Java Enterprise and Open Source technologies. You can access my personal website at www.techvj.com.

Now, with the short introduction out of the way, get ready for the Blog Attack…