Sunday, April 17, 2011

Diamond Problem and Scala Traits

In object-oriented programming languages with multiple inheritance and knowledge organization, the diamond problem is an ambiguity that arises when two classes B and C inherit from A, and class D inherits from both B and C. If a method in D calls a method defined in A (and does not override the method), and B and C have overridden that method differently, then from which class does it inherit: B, or C?

Java's approach to this problem was to prevent developers to extend from multiple classes but provide them options to implement multiple Interface(s). Scala provides a more clean implementation similar to the Ruby's mixin concept (I'm 0% into Ruby) called Traits. So, how does Scala solve this problem. Check the code below:

abstract class A{
def isWhat():Boolean

trait B extends A{
override def isWhat():Boolean = true;

trait C extends A{
override def isWhat():Boolean = false;

val a = new A with C with B;

The output is:

scala TraitLearn.scala

So, instead of getting confused to identify which method to execute it has left it to the discretion of the developer. The actual purpose of traits is not what is shown above but what I like it more than the interface is its ability to have partial implementation.

By the way, I bought a new MacBook Pro and the very first thing to try in it was Scala. :-)

Tuesday, April 12, 2011

Why is toArray() a generic method in Java Collections?

Probably some java enthusiast can answer this question for me. I was referring to the Collections API to convert a list to array. I was shocked to find that the method was generic.

<T> T[] toArray(T[] a)

I was wondering why the method was declared generic when the type is itself declared with one. So, in order to convince myself, I wrote the following code and a test case. Please excuse if the code looks odd and isn't following any standard; its written quickly for the purpose of this blog.

public class AList<E> {

private final List<E> list;

public AList(List<E> list) {
this.list = list;

public boolean add(E value){
return this.list.add(value);

public int size(){
return this.list.size();

public E[] toArray(E[] a) {
System.arraycopy(list.toArray(), 0, a, 0, size());
return a;


The first part of the test case is for pre-Java5 collection and the next for the type safe Java 5 way.

public void testAListToArray() {
AList list = new AList(new ArrayList());
list.add("Not type safe");
String[] sl = (String[]) list.toArray(new String[list.size()]);
assertEquals(sl.length, list.size());

AList<String> list2 = new AList<String>(new ArrayList<String>());
list2.add("Type safe");
String[] s2 = list2.toArray(new String[list.size()]);
assertEquals(s2.length, list2.size());

Both worked perfectly fine and the test passed. So, back to square one --> I'm unable to figure out why they method is declared generic with an additional parameterized type.

Monday, April 11, 2011

Just for gigs...

This is a sequel to my earlier post - Numbers: Not everything is magic.

If I show the numbers 1024, 2048, 4096... to a software geek, the immediate answer would be around bits and bytes. But these numbers have another peculiar pattern.
1024 is the first positive integer to satisfy the condition.
an+2 + an = (2a)n

It is followed by the remaining numbers. Check the following:
102422 + 102420 = 204820
204824 + 204822 = 409622
409626 + 409624 = 819224
819228 + 819226 = 1638426
1638430 + 1638428 = 3276828

Now the hack to find it.
an+2 + an = (2a)n
=>an (a2 + 1) = 2 n an
=>a2 + 1 = 2 n
=>a= (2 n - 1)1/2

Now, let us find out a way to solve the below equation:
an+x + an = (2a)n
=>an (ax + 1) = 2 n an
=>ax + 1 = 2 n
=>a= (2 n - 1)1/x

So, for n and n+4, the first positive integer to satisfy is 64.

Last but not the least for the post.
an+x + an = (k*a)n
=>an (ax + 1) = k n an
=>ax + 1 = k n
=>a= (k n - 1)1/x
So for k=3 and x = 1, the numbers are 2, 8, 26, 80...

Friday, April 8, 2011


OpenJPA is a JPA framework very light compared to the heavyweight Hibernate. In order to provide optimal runtime performance, flexible lazy loading, and efficient, immediate dirty tracking, OpenJPA can use an enhancer . An enhancer is a tool that automatically adds code to your persistent classes after you have written them. The enhancer post-processes the bytecode generated by your Java compiler, adding the necessary fields and methods to implement the required persistence features. This bytecode modification perfectly preserves the line numbers in stack traces and is compatible with Java debuggers.

This is my third stint with EMMA and I simply love it even over the much detailed Clover. Apart from the free factor, its pretty fast and has less memory overhead. In one of my project, our nightly CI job with clover used to crash with clover which forced us to stick with EMMA. Instrumentation is an important step to get the coverage. The instrumentor adds bytecode instrumentation to all classes found in an instrumentation path that also pass through user-provided coverage filters. Additionally, it produces the class metadata file necessary for associating runtime coverage data with the original class definitions during coverage report generation.

Unfortunately, OpenJPA enhancer and EMMA instrumentor don't jell together. Yes, there's a conflict between them. As a result, your coverage will be incomplete. So, options left out will be
1. To switch over to Cobertura(sic) or Clover.
2. To filter the Dao and JPA entity classes from the coverage (sic again).

Depending upon your flexibility and need, you can choose one of them.

Tuesday, April 5, 2011

Numbers: Not everything is magic

In my previous post - Number Magic, I scribbled that I found a pattern as follows...
- For any number n from 1 to 10 and any number k that satisfy the condition - k^n + k^(n+1) = (k+k)^n the next such condition is satisfied by (2k+1). But actually, there was an interesting solution. Lets put it in plain equation.

k^(n+1)+k^n = (2k)^n

So, the number thats satisfies are 1, 3, 7, 15...1267650600228229401496703205375...

What is my learning here? - Get back to the basics... Or should I say to myself KISS - Keep it Simple, Stupid!!!

Sunday, April 3, 2011

Number Magic

Thanks to a post from one of my old manager, mentor and friend - Anand Mohanram - 10 (Square + Cube pattern - Interesting Number Pattern), I was able to find an interesting pattern. Some were commented to his facebook posts.
1. The difference between the cube numbers over their previous square partners is an arithmetic progression with common difference of 1. See them below:

Actually, we can easily find the numbers matching the pattern by solving the equation:
a^3+b^2 = (a+b)^2;
=>a^3+b^2 = a^2+b^2+2*a*b;
=>b = a*(a-1)/2

This explains the AP of constant 1 between the numbers for every value of a.

Java Source code that helped to find this (though its of no use now) :

public void findSquareCubeNumbers(int count){
for (int i = 1; i < count; i++){
int num = i*i*i;
for (int j = 1; j < count; j++){
int sum = i+j;
if (num+(j*j)==sum*sum){

2. For any number n from 1 to 10 and any number k that satisfy the condition - k^n + k^(n+1) = (k+k)^n
the next such condition is satisfied by (2k+1).
The below illustration is the proof:
(k= 1((2*0)+1); n= 1) 1^1+1^2=2^1
(k= 3((2*1)+1); n= 2) 3^2+3^3=6^2
(k= 7((2*3)+1); n= 3) 7^3+7^4=14^3
(k= 15((2*7)+1); n= 4) 15^4+15^5=30^4
(k= 31((2*15)+1); n= 5) 31^5+31^6=62^5
(k= 63((2*31)+1); n= 6) 63^6+63^7=126^6
(k= 127((2*63)+1); n= 7) 127^7+127^8=254^7
(k= 255((2*127)+1); n= 8) 255^8+255^9=510^8
(k= 511((2*255)+1); n= 9) 511^9+511^10=1022^9
(k= 1023((2*511)+1); n= 10) 1023^10+1023^11=2046^10

Java Source code that helped to find this:

public void findNextPowerNumbers(int powVal, int count){
double prevK = 0;
for(double i = 1; i < powVal; i++){
double power = i+1;
for (double k = 1; k < count; k++){
double num = Math.pow(k, power);
double num1 = Math.pow(k, i);
double sum = 2*k;
double num3 = Math.pow(sum, i);
if (num+num1 == num3){
System.out.println("(k= "+k+"((2*"+prevK+")+1); n= "+i+") "+k+"^"+i+"+"+k+"^"+power+"="+sum+"^"+i);