Anand Rajasekar

Timemachine and Psync

anandsekar — Tue, 09 Feb 2010 15:36:35 +0000

I have started using Timemachine to backup my computer. It was very simple to setup. One nice feature is that internally the incremental backups use links to refer to unchanged old files so opening the backup in finder shows the complete view.
For my secondary backup snapshot I use pync which synchronizes my data with my network hard drive.
I had bad experiences with all the GUI frontends to psync, so I would recommend to stay away from the GUI and stick to scripts.

SyncBack vs SyncToy

anandsekar — Sat, 14 Nov 2009 13:24:30 +0000

I have been using Microsoft’s synctoy a lot. After moving all my computing to a Mac, I still have been running synctoy on parallels to get my backups done. When moving from Vista to Windows 7 I found so many quirks in synctoy that I have finally settled with SyncBack. SyncToy maintains a database of the file meta data and hence has the ability to find out which files were deleted in a synchronized folder, however since it has a database using your existing backup with a new synctoy installation just does not work. You have to redo the entire backup, which was not an option as I had about 40 GB of data.

I tried SyncBack and I I have been very happy. It is much much faster than sync toy, always consistent and simple. Since it does not store the file metadata, and you delete a file in the primary folder, you need to specify specify if you want to delete or copy over the file from the passive folder pair.

Optimizing Windows Vista for Parallels

anandsekar — Tue, 03 Nov 2009 03:38:06 +0000

I have finally moved all my computing to my MacBook. I used Parallels to run Windows Vista in Mac mostly to run Quicken. It was painfully slow. To speed up Windows Vista open up the display performance settings and set it to “Adjust for Best Performance”. With this setting Windows Vista is considerably faster

Time Lapse of Sunset from Milpitas Hills

anandsekar — Mon, 08 Jun 2009 08:24:50 +0000

Untitled from Anand Rajasekar on Vimeo.

Tomcat Initializing Servlet Twice

anandsekar — Thu, 28 May 2009 16:44:21 +0000

A web application is configured using tomcat’s server.xml and the context.xml. There some configurations that cause web applications to initialize twice like

Duplicate definition of context in context.xml and server.xml
Bugs in tomcat launchers for eclipse that create duplicate context definitions
Duplicate definition of contexts when defining multiple hosts

In my case I had a proper definition of the context and the problem was I was using a exploded war deployment format and my root directory was named .war , This was causing tomcat to treat it as a war file and a directory and initializing it twice.

The problem vanished after removing the .war extension to the directory. This happened to me on tomcat 6.0.16

Three makes it perfect

anandsekar — Mon, 18 May 2009 04:31:11 +0000

Sometimes creating a collage of similar photographs adds a stunning effect. Here are three photographs of Aradhana stacking blocks.

Photographing Running Children

anandsekar — Mon, 18 May 2009 04:17:16 +0000

Capturing a sharp photograph of a running child can be quite a challenge. Canon has a focusing mode called AI Servo that makes focusing moving objects very easy. This mode uses the auto focus motor to continuously focus on the object in the center of the view finder.

This photograph was taken with my Digtal Rebel XT, 50mm prime lens at f/1.8 ISO 200 1/400s

AI Servo mode makes photographing running children much easier, especially when you are shooting with a high aperture in low light.

Java Serialization Versioning with Externalizable

anandsekar — Wed, 22 Oct 2008 05:39:06 +0000

Java Serialization is a easy way to persist the state of Java Objects. However if the structure of the class changes the serialized bytes is invalidated by the changes. This article suggest how one could implement serialization with Externalizable with support for versions.

Consider a simple java class

public class SimpleObject implements Serializable {
private int field1;
private int field2;
}

If the structure of the class changes, then the serialized bytes becomes incompatible and you would get the dreaded ClassCastException

public class SimpleObject implements Serializable {
//private int field1; removed
private int field2;
private int field3; //added
}

A good way to get complete control of the serialization and support version is by implementing Externalizable instead of Serializable.

Externalizable gives the programmer full control over how the class is serialized and de-serialized. It is common practice to add a version variable to support representations of the same class over time.

Consider first version of the same class

public class SimpleObject implements Externalizable {
private int version=1;
private int field1;
private int field2;
@Override
public void readExternal(ObjectInput in) throws IOException,
ClassNotFoundException {
version=in.readInt();
if(version==1) {
field1=in.readInt();
field2=in.readInt();
} else {
throw new IOException(“Invalid Version”);
}
}
@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeInt(version);
out.writeInt(field1);
out.writeInt(field2);
}
}

Now if the next version of the class needs to add a String and remove field2 the class would look like

public class SimpleObject implements Externalizable {
private int version=2;
private int field1;
//private int field2; removed
private String version2String;
@Override
public void readExternal(ObjectInput in) throws IOException,
ClassNotFoundException {
version=in.readInt();
if(version==1) {
field1=in.readInt();
in.readInt();// ignore
version2String=“”;// initialize to default
} else if (version==2) {
field1=in.readInt();
version2String=(String) in.readObject();
} else {
throw new IOException(“Invalid Version”);
}
}
@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeInt(version);
out.writeInt(field1);
out.writeObject(version2String);
}
}

Modifying Classpath at Runtime

anandsekar — Wed, 27 Aug 2008 20:19:35 +0000

A hackish way of modifying the classpath at runtime can be done in a way described at the java forums Modifying Classpath at Runtime
A cleaner approach is to configure your own classloader and set it as the threads context classloader

URL[] urls=new URL[2];
URLClassLoader classLoader=new URLClassLoader(urls);
Thread.currentThread().setContextClassLoader(classLoader);

This is extremely useful if your unit test cases have dependencies that you would like to load at runtime

InheritableThreadLocal and Tomcat

anandsekar — Thu, 08 May 2008 05:18:40 +0000

InheritableThreadLocal does not work with tomcat as tomcat thread pool does not clear the thread local contacts after a request has been executed. This results in no good way to share information information between the parent and the child threads that are created using thread local variables.

One way to solve this problem is to maintain a reference to the parent thread by writing your own thread that is constructed by a thread factory.

public class MyThread extends Thread {
private Thread parent;
public MyThread(Thread parent) {
super();
this.parent = parent;
}
public Thread getParent() {
return parent;
}
}

import java.util.concurrent.ThreadFactory;
public class MyThreadFactory implements ThreadFactory {
@Override
public Thread newThread(Runnable arg0) {
return new MyThread(Thread.currentThread());
}
}

import java.util.HashMap;
import java.util.Map;
public class ClassNeedingInheritableThreadLocal {
private Map inheritableThreadLocal=new HashMap();
public Object getInheritableThreadContext() {
return inheritableThreadLocal.get(getThread());
}
public void setInheritableThreadContext(Object context) {
inheritableThreadLocal.put(getThread(), context);
}
private Thread getThread() {
Thread currentThread=Thread.currentThread();
if(currentThread instanceof MyThread) {
currentThread=getParent((MyThread) currentThread);
}
return currentThread;
}
public Thread getParent(MyThread myThread) {
Thread parent=myThread.getParent();
if(parent instanceof MyThread) {
return getParent((MyThread) parent);
} else {
return parent;
}
}
}

Create a executor service by using our thread factory

ExecutorService service=Executors.newFixedThreadPool(10, new MyThreadFactory());

Remember that you would need to clean up all the objects that were put in the thread local. This can be done with a filter or by using AOP.