why is there a difference and how to make them work together?
The vast majority of the documentation for this plugin indicates that you initialize it with
$('#example').dataTable();
initializes using
$('#example').DataTable();
The resultant objects differ quite a lot, and the example URL above doesn't work when you initialize with a lower-case 'D', however pretty much everything else requires the lower-case 'D' initialization

Basically, the two constructors return different objects.
dataTable constructor
var table = $(<selector>).dataTable()
dataTable is the oldschool dataTables constructor, which returns a jQuery object. This jQuery object is enriched with a set of API methods in hungarian notation format, such as fnFilter, fnDeleteRowand so on. 
Examples :
table.fnDeleteRow(0);  table.fnAddData(['E', 'F']);
dataTable is supported by all 1.9.x / 1.10.x versions.

DataTable constructor

var table = $(<selector>).DataTable()

The DataTable constructor was introduced in 1.10.x, and returns a huge API object with full read/write access to pages, rows, cells and more,
Example equivalences :
         table.row(0).remove();         table.row.add(['E', 'F']).draw();


Combining dataTable and DataTable

If you maintain old code, or for some reason need to use the oldschool dataTable constructor, but still needs to use the new API, the jQuery object is extended (from 1.10.0) with a .api() method that returns the new API. 
Example equivalences :
var table = $('#example').dataTable();
table.api().row(0).remove(); table.api().row.add(['E', 'F']).draw();
The old API like table.fnDeleteRow(0) still works. 

As you see, you can do both! Initialize dataTables the old way, and use .api() when you need access to the new API.

For Details and features in new version refer to following link"
http://www.datatables.net/new/1.10
Difference between SubStr() and SubString()

SubString():
The substring() method extracts the characters from a string, between two specified indices, and returns the new sub string.
This method extracts the characters in a string between "start" and "end", not including "end" itself.
If "start" is greater than "end", this method will swap the two arguments, meaning str.substring(1,4) == str.substring(4,1).
If either "start" or "stop" is less than 0, it is treated as if it were 0.
Syntax:  string.substring(start,end)
Eg:
var str = ”Differences”;
alert(str.substring(0, 4));  // would print "Diff"

SubStr():

The substr() method extracts parts of a string, beginning at the character at the specified position, and returns the specified number of characters. 

Syntax: string.substr(start,length)

Eg:  var str = "Differences"
     alert(str.substr(0, 4));  // this will also return "Diff"

We have seen how both functions work but if u have identified there is a difference how both functions work.
Both functions used to extract string
Both functions have 2 parameters
Both functions have initial parameter as starting position
But both functions dosen’t have same second parameter
SubStr() has end position as second parameter
SubString() has length as second parameter
Though above example returns same result, but here logic is different, as here starting index is zero and length of substring is 4, which means four characters long string, which starts from first character, that's why "Diff". If we apply different argument we will get different result.So the result of both functions return different which can be seen in below example
var str = "JavaScript"
alert(str.substr(4, 6)); // this will return Script

alert(str.substring(4, 6)); // this will return "Sc"

Here, you can clearly see that both substr and substring are returning different result, because starting index is not zero. Because of this many web developer often confuse and they think that substr and substring behave identically, which is not true. You should be very careful, while using substr() and substring(), otherwise it will create hard to find subtle bugs. There is another method called slice() which can also be used for creating smaller substring from String in JavaScript, and you can think of it to avoid any confusion between substring and substr in JavaScript.
Difference Between Array List  and Linked List



1. Both array list and Linked list “Implement list Interface”
2. They both maintain the elements insertion order which means while displaying Array 
List and Linked List elements the result set would be having the same order in 
 which the elements got inserted into the List
3. Both are non-synchronized classes




When to use Linked List and when to use Array List?

1) As explained above the insert and remove operations give good performance (O(1)) in Linked List compared to Array List(O(n)). Hence if there is a requirement of frequent addition and deletion in application then Linked List is a best choice.

2) Search (get method) operations are fast in Array list (O(1)) but not in Linked List (O(n)) so If there are less add and remove operations and more search operations requirement, Array List would be your best bet.