My perspective

Some of the most frequent methods you might be using if you are a Web Dev. - .live(), .bind() and .delegate(). I’ve used live() and bind() quite frequently but never understood the performance implications of these methods. This blog nails the Pros. and Cons. of using them.

http://www.elijahmanor.com/2012/02/differences-between-jquery-bind-vs-live.html

Happy Coding!

I have always been under an impression that if I wanted to implement a cache I can always use WeakHashMap! No. WeakHashMap is not a cache. Simply because it uses weak references for keys and not for its values(that you might want to cache). WeakHashMap is an excellent choice if you want to store meta data about an object that you dont have control to change it.

For e.g., WeakHashMap<Socket, countOfOpenClients> or WeakHashMap<Thread, memoryFootPrint>

But if you want to implement a cache, you might want to consider a structure like Map<K,SoftReference< V > >. Since V is referred by a soft reference(and not by any strong reference), V will be garbage collected under low memory situations. Cache’s get(K) will return null and so the cache might want to reload the value from the disk and store a soft reference to it.

If you dont want an infinite capacity cache, you can always have a maxCapacity and also implement remove() method to decide which candidate has to be removed. You can also heat up an item based on some strategy. One such is  LRU.

I had a habit of not using iterators when using/iterating over data structures until today when I was using a SparseArray in Android. Here is an explanation on why everyone should consider using iterators or if you are writing your own data structure you should implement your own iterator.

When using a SparseArray in Java, you can iterate like the following:

private void print(SparseArray sArr) {

    int len = sArr.length;

    for (int i = 0; i < len; i++) {

        Double value = (Double) sArr.fetch(i);

        System.out.println(value);

    }

}

This could be a poor implementation of print function for a sparse array where many slots would just be empty/null/zero. Here is where iterators help us to use the real potential of the data structure. Sparse array normally stores its elements along with the index value. In a linked list based implementation, these both will form a node along with the next pointer pointing to the next available value/index. Look up for values in between these two nodes will return zero or null. This is the most important thing one has to remember regarding how sparse arrays are implemented efficiently. The above code does n’t do any good for us since it does a look up for all the elements. An iterator based usage will look like:

while (iterator.hasNext()) {

    value = (Double) iterator.next()

    System.out.println(value);

}

Iterator pattern is an important design pattern that every data structure developer should implement to enable the users to fully exploit its potential.

Today, I happen to solve a problem that frequently involved a 4-level look up to a different process and get a reference and then use it for good. I stumbled upon this holder pattern that helped me to optimize a lot. Basically, you might have to create a static inner class for your holder. In Java, it could like this,

static class MyHolder {

static final Class_Name sReference = Manager.Stub.Interface.getService(); //IPC

} and then in future, if you want to query again, you can use MyHolder.sReference.query()

While reading further, I found a great demo from Android dev page http://developer.android.com/resources/samples/ApiDemos/src/com/example/android/apis/view/List14.html

So, look for frequently called external api in your code. Cache their results in your class if you can.

On a side note, I have also seen some programmers writing for-loops like,

for(int index=0; index<bigArray.size(); index++) {}

Whenever I code review, I always -1 this line :) I dont like spending o(size-of-bigArray) everytime(sometimes compilers could cache them for you) in the loop. I would use a local variable ‘holding’ the size instead. int len = bigArray.size();

Happy coding!