Keep Walking!

Proposed Apache Flex Logos | Round II - Results

2012-01-27T18:09:00.000+05:30

The Apache Flex logo contest came to end today with the results for Round 2 being announces by Doug Arthur. And the winner is,

Logo #42:
Total: 77 Votes
Community: 61 *
PPMC: 16 *

Logo #49:
Total: 49 Votes
Community: 44
PPMC: 5

Congrats to the team behind logo #42.

Full results are available here (PDF).

Quoting Doug,

Finally, Tomasz Maciag's logo will appear as the new Apache Logo (As stated in the contest rules, tweaks will be allowed now that the contest has been finalized. )

For the over eagerly,

Disclaimer: I voted for #42.

Proposed Apache Flex Logos | Round I - Results

2012-01-24T18:00:00.000+05:30

From among all the contenders, after the first round of voting, the results are as under:

Logo #49:
Total: 106.5 Pts
Community: 83.5 *
PPMC: 23

Logo #42:
Total: 99.5
Community: 68.5
PPMC: 31 *

Logo #40:
Total: 65
Community: 63
PPMC: 2

A list of aggregated first round results is available here.

The voting will now continue to choose the one from these three.

Disclaimer: The results are based on the vote of the community on Apache Flex Dev mailing-list.

Happy Flexing!

Proposed Apache Flex Logos | Part II

2012-01-07T21:42:00.001+05:30

In continuation of my previous post on Proposed Apache Flex Logos here are some more logos that have been posted. Check them out.

By Mihai Ene

By Carlos Rovira - Updated

By Peter Elst

Update: 9 Jan 2012

By Doug McCune

Proposed Apache Flex Logos

2012-01-06T09:26:00.001+05:30

As we all have heard that Adobe has started donating the Flex framework to the Apache foundation. The project was approved over the holidays and the combat has begun.

The first blood was shed yesterday with some designers proposing new logos for the Apache Flex framework. Below are the logos submitted by the time of writing. Please vote for your favorite ones at the project's mailing lists.

In case you are enthusiastic enough and are a designer, it would be helpful to propose your own thoughts for the same. Make sure you go over the Individual Contributor License Agreement for you would need to donate your work to Apache in its accordance.

Without much ado, in no particular order:

By Erik Lundgren

By Rick Winscot

By Tink

By Randy Troppmann

By Carlos Rovira

Happy Flexing! :)

Mission Accomplished - Greplin Programming Challenge!

2011-12-08T16:57:00.001+05:30

After a lull yesterday, I could finally find time to solve the third puzzle in the Greplin Programming Challenge. At first the puzzle seemed tricky, considering my bad with combinatory logic with numbers. However after many trials and errors I could solve the puzzle. And now I can sit and relax, and look at my stupid face as to why I was writing over 100 lines of code to solve, when the solution was simply a few lines.

Anyways, am done with the challenge and I have my passcode now! Next steps involve dropping them a mail with my solutions.

For those interested, the code is available on my GitHub repository.

Happy Coding!

Greplin Programming Challenge

2011-12-07T10:08:00.001+05:30

Yesterday evening I came across another programming challenge called Greplin Programming Challenge. The challenge presents three problems which requires one to write small pieces of code to solve, and provide the solution as the password to the next level. Something similar to Project Euler problems.

The challenge claims it may take from anywhere between 20 minutes and 2 hours. The first and second level are quite easy and should be completed within 15 minutes (including the time to fire up the IDE and keying in code, lazying around in bed). The third level requires some combinatory logic and thus may require a little extra time. I am done with the first 2 levels and planning for the third today evening.

For those interested, the code is available on my GitHub repository.

Looks like am developing a liking for coding problems... Anyone recommending another?

Have. Fun. Coding.

Image Unshredder - Update

2011-12-07T09:48:00.001+05:30

In continuation of my earlier post about Instagram's Engineering Challenge on an Image Unshredder, I took some time out yesterday and completed the automatic strip width detection piece. The approach was easy, the euclidean distance on the strip edge will be too high than the normal values. For example the values may look like,

3, 4, 3, 5, 3, 2, 6, 22, 4, 3, 2, 3, 4, 3, 2, 27, 3, ...

One just needs to take the average of above values, then find the average of values greater than this average. Once you have the maxAverage, one can run a loop and find the value where the ratio of (value / minimum) is close to the ratio of (maxAverage / minimum). The first index where this happens is the strip width. To be doubly sure that we have chosen the right value, make sure the strip width divides the image width in whole.

I tested my code with many a free images from Flickr and it all worked. Though I did find a couple of issues with images that had a dark background and no front object - like a huge clear sky running in.

As the challenge was to unshred the shredded Tokyo image, it stands completed. The remaining improvements, I will leave for some other day.

I have also added an image shredder and a test suite that takes in images from a given folder, shreds and then unshreds them.

For those interested the code is posted on my GitHub repository at https://github.com/sangupta/image-unshred

Instagram's Engineering Challenge: The Unshredder

2011-12-06T09:00:00.000+05:30

Three weeks ago, Instagram posted an engineering challenge: The Unshredder. The challenge presented an image that had been vertically shredded/spliced and then rejoined randomly, thus resulting in an image that looks like a puzzle. What one had to do was to write a script to take that image and unshred it - yes, reconstruct the original image.

From their blog,

Your challenge, if you choose to accept it, is to write a simple script that takes a shredded image in as input:

and outputs an unshredded and reconstituted image. That is, imagine if you took an image, divided it into an even number of columns and shuffled those columns randomly to produce a shredded image. Then, take that image into the script and output the original image:

I happened to read and pick up this challenge yesterday, and it was surprising to find that the solution was a very simple best-match function that had to place a given slice alongside another based on how close the left-pixels of one were to the right-pixels of another. I used Java and the built in AWT package to load the image and read the pixel colors at various coordinates. Reconstructing the image was again super easy using AWT. To test that the solution was a generic one, I sliced some 50 random images and then reconstructed them using my code for varying slice-widths - ranging from 4 pixel wide to 64 pixel wide.

My algorithm worked in the following way:

Find out the number of stripes in the image (as the strip-width is known)
Slice the image and store all sub-images in a given array
Pick the first slice from the array
Now for each other slice in the array (slices that have not yet been used) - compute the average Euclidean distance of the left edge of the given slice and the right edge of the test slice. Similarly, compute the average distance of the right edge of the given slice and the left edge of the test slice.
Find the slices that have the least scores for left and right side
Now, insert the one of the test slice to the left or to the right, depending on which test slice and edge had the lowest average distance
Work this way to arrange each unused slice to the set of arranged slices
At the end, you have all the slices in order resulting in the reconstructed image

For those interested the code is posted on my GitHub repository at https://github.com/sangupta/image-unshred

I haven't yet completed the bonus part of it due to lack of time, but hope to push it in a day or two.

Happy Coding!

The Luhny Bin

2011-11-17T19:42:00.001+05:30

Two days ago, Bob Lee posted a fun challenge on the Luhny Bin. It was not before a day has passed that I could get to know of the problem and try my hands at it. The delay being attributed to absence of Cygwin on my Windows machine which was needed to run the test harness (refer original post on details).

Yesterday, I spent most of my time first trying to get the harness running without using Cygwin. The solution was a bit tricky as I had to figure out how the test harness was actually running. Anyhow, my solution is available at here wherein I modified the original Main.java file. The change was simple: first, change mask.sh on line 41 to say mask.bat and second, modify line 81 to correctly build the process.

Once, I had it setup and after loosing all day, I was ready to start coding the actual solution. Before I dozed off to my bed, I had made sure that my code passed 18 of the 20 tests. The 19th test was tricky. It had many over-lapping luhn numbers, and hence I had some leftover in the end which was not being cleaned up. This single test made me completely rewrite the piece introducing a third buffer (which came down to two, as I directly now wrote to System.out).

Anyways, the solution is now complete and posted on my fork of the LuhnyBin Github repository.

EGit GitHub Commit API and Commit Stats

2011-11-10T21:48:00.001+05:30

While working today with EGit for the GitHub API, I found out that there is no way to get the Commit statistics and the various file details. If you ponder over the API details at http://developer.github.com/v3/repos/commits/,

GET /repos/:user/:repo/commits/:sha

the response for the API contains details about the lines added/deleted in the commit. The response also contains details about the various files that are impacted. See the *stats* and the *files* section below:

{
  "url": "https://api.github.com/repos/octocat/Hello-World/commits/6dcb09b5b57875f334f61aebed695e2e4193db5e",
  "sha": "6dcb09b5b57875f334f61aebed695e2e4193db5e",
  "commit": {
    "url": "https://api.github.com/repos/octocat/Hello-World/git/commits/6dcb09b5b57875f334f61aebed695e2e4193db5e",
    "sha": "6dcb09b5b57875f334f61aebed695e2e4193db5e",
    "author": {
      "name": "Monalisa Octocat",
      "email": "support@github.com",
      "date": "2011-04-14T16:00:49Z"
    },
    "committer": {
      "name": "Monalisa Octocat",
      "email": "support@github.com",
      "date": "2011-04-14T16:00:49Z"
    },
    "message": "Fix all the bugs",
    "tree": {
      "url": "https://api.github.com/repos/octocat/Hello-World/tree/6dcb09b5b57875f334f61aebed695e2e4193db5e",
      "sha": "6dcb09b5b57875f334f61aebed695e2e4193db5e"
    }
  },
  "author": {
    "login": "octocat",
    "id": 1,
    "avatar_url": "https://github.com/images/error/octocat_happy.gif",
    "url": "https://api.github.com/users/octocat"
  },
  "committer": {
    "login": "octocat",
    "id": 1,
    "avatar_url": "https://github.com/images/error/octocat_happy.gif",
    "url": "https://api.github.com/users/octocat"
  },
  "parents": [
    {
      "url": "https://api.github.com/repos/octocat/Hello-World/commits/6dcb09b5b57875f334f61aebed695e2e4193db5e",
      "sha": "6dcb09b5b57875f334f61aebed695e2e4193db5e"
    }
  ],
  "stats": {
    "additions": 104,
    "deletions": 4,
    "total": 108
  },
  "files": [
    {
      "filename": "file1.txt",
      "additions": 10,
      "deletions": 2,
      "total": 12
    }
  ]
}

As I needed these values, I happened to go over the source code for *EGit* and find a way around. Must say, the way the source code is structured makes it super-easy to modify the code for additional API values.

Below are the two simple changes I made to make sure the API returns the details I needed,

Add the following class org.eclipse.egit.github.core.Stats

package org.eclipse.egit.github.core;

public class Stats {
 
 private int additions;
 
 private int deletions;
 
 private int total;

 public int getAdditions() {
  return additions;
 }

 public void setAdditions(int additions) {
  this.additions = additions;
 }

 public int getDeletions() {
  return deletions;
 }

 public void setDeletions(int deletions) {
  this.deletions = deletions;
 }

 public int getTotal() {
  return total;
 }

 public void setTotal(int total) {
  this.total = total;
 }

}

Modify the class org.eclipse.egit.github.core.RepositoryCommit to add the following lines:

private Stats stats;
 
 private List<CommitFile> files;

 public Stats getStats() {
  return stats;
 }

 public void setStats(Stats stats) {
  this.stats = stats;
 }

 public List<CommitFile> getFiles() {
  return files;
 }

 public void setFiles(List<CommitFile> files) {
  this.files = files;
 }

And we are done. Calling the following API,

public void test() {

    CommitService commitService = new CommitService();

    RepositoryCommit commit = commitService.getCommit(repository, sha);

    System.out.println("Total lines impacted: " + commit.getTotal());

    System.out.println("Total files impacted: " + commit.getFiles().size());
}

should return back the various statistics as returned by *GitHub*.

Hope this helps!

Update: Added the files as a GitHub gist at https://gist.github.com/1355351

Preview: Connecting Content and Community in the Cloud

2011-10-10T12:10:00.001+05:30

Jay Dutta, Experience Design Manager and Luanne Seymour, Sr. Instructional Designer at Adobe presented a Social Study on how to connect content and community in the cloud at Adobe MAX 2011.
As mentioned for the video,

See how a few simple UX design patterns can facilitate a shared, social learning experience that blurs the boundaries between inspiration and instruction, as well as between content and community. Three trends are currently sweeping digital media: Tablets are moving from content consumption to creation, social features are increasingly pervasive, and everything is shifting to the cloud. Join us to explore how this trifecta creates exciting opportunities for designers and developers, and to examine our own promising effort at taking advantage of these trends.

Watch the video on Adobe TV or,

AIR 3.0 Native Extensions and Samples

2011-10-04T13:50:00.001+05:30

Today at MAX 2011, Adobe released the latest version of their Flash platform SDKs - Flash Player 11 and AIR 3.0. The most noticeable and exciting amongst new features of AIR 3.0 is the introduction of Native Extensions. Native Extensions allow a developer to extend the capabilities of the AIR platform by running native code directly from their AIR applications. Quoting from Adobe's site,

This new capability allows developers to:

Achieve deeper integration with target devices

Incorporate legacy native code in their application

Achieve maximum performance for critical code

I am not going to delve into what the feature introduces a developer to, for the same one may go ahead and read this article by Oliver Goldman.

Following are the links to the various Native Extensions that have been built and are available for ready use:

A Hello World example to beign with
Push Notification native extension sample for Android and iOS
Licensing Adobe AIR applications on Android
Gyroscope native extension sample
NetworkInfo native extension sample
Vibration native extension sample
iBattery for iOS native extension sample
Image Processor native extension sample for Windows
Kinect native extension library
Android Cloud to Device Messaging Framework native extension library
Read Pressure Sensitivity of a Pen Tablet on Windows

If you know of more example extensions that are publicly available, please drop a comment and I will include them in the list.

Function Overloading in ActionScript

2011-09-26T10:37:00.000+05:30

We all know that function overloading, or for that matter Constructor overloading, is not supported in ActionScript. This is not a big deterrent till what you are writing your own code, but becomes a major blocker when you plan to port some code from a code piece written in another language. Recently, I have started migrating one of the de-facto open-source Java software to ActionScript. And the piece is huge. Giving different names to each overloaded method and then making sure that you call the right one tends to get complicated.

Assigning a variable Object to method arguments and then writing the overloaded method is so so messy and ugly. While porting this piece, this problem had been in my mind for almost a week now, and today morning it occurred that I could use abstraction to solve my problem. To outline the methodology I adopted to solve this problem is as under. Suppose you have the following java code,

public class Example {

    public void method(int x) { ... }

    public void method(int x, int y) { .... }

    public void method(String x) { .... }

    public void method(int x, String y) { .... }

}

The most commonly used methodology when porting to ActionScript would be,

public class Example {

    public function method(x:*, y:* = undefined):void {
        if(x is int && y is undefined) { ... }

        else if(x is String && y is undefined) { ... }

        else if(x is int && y is int) { .... }

        else if(x is int && y is String) { ... }
    }

}

This method has its own disadvantages as it looses type safety. We can thus utilize abstraction to make sure that we achieve the method overloading without loosing the type safety as below. First, define a marker interface that indicates that a given class encapsulates arguments for a given method, such as,

public interface IMethodArguments {

}

Next define one class for each of the arguments type and the number of arguments as,

public class SingleIntegerArguments implements IMethodArguments {

    public var x:int;

}

public class TwoIntegerArguments implements IMethodArguments {

    public var x:int;

    public var y:int;

}

public class SingleStringArguments implements IMethodArguments {

    public var x:String;

}

public class IntegerStringArguments implements IMethodArguments {

    public var x:int;

    public var y:String;

}

Lastly, modify the original method to check against the implementing class of the object passed as argument. This makes sure that none of the variables declared anyplace is of type Object or Variable '*'.

public class Example {

    public function method(argument:IMethodArguments):void {
        if(argument is SingleIntegerArguments {
            ...
        } else if(argument is TwoIntegerArguments) {
            ...
        } else if(argument is SingleStringArguments) {
            ...
        } else if(argument is IntegerStringArguments) {
            ...
        }
    }
}

The method outlined here is nothing novel but just a different approach to providing a functionality that is very common in the programming world in a type-safe way.

Hope this helps.

parseDouble() in Java

2011-09-22T12:21:00.003+05:30

Problem: Impement the Double.parseDouble() method of Java.

Solution: A classic interview problem where one needs to check in for all boundary combinations and all representations of a number. The following number representations are perfectly fine and should be accounted for,

23
+23
-23
+0.23
-0.23
.23
-.23
00000.23
0.23000000

The code for the same is as under, and is also available on GitHub for reference.

/**
 * Copyright (C) 2011, Sandeep Gupta
 * http://www.sangupta.com
 * 
 * The file is licensed under the the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * 
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * 
 */

package com.sangupta.keepwalking;


/**
 * A simple Java implementation of the Java's Double.parseDouble() function.
 * 
 * @author Sandeep Gupta [email]
 * @version 1.0
 * @since 22 Sep 2011
 */
public class ParseDouble {
	
	/**
	 * Some tests to run.
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		System.out.println(parseDouble(".23"));
	}

	/**
	 * A simple implementation that takes a number as a string and converts it
	 * to a double method, similar to what Double.parseDouble() does.
	 * 
	 * The following number values are supported,
	 * +23
	 * -23
	 * +0.23
	 * +.23
	 * 0.23
	 * .23
	 * 0000.23
	 * 0.23000
	 * 
	 * @param string the string representation of the number
	 * @return the double value
	 * @throws NumberFormatException if the string does not represent a number or is malformed
	 */
	private static double parseDouble(String num) {
		if(num == null || "".equals(num.trim())) {
			throw new NumberFormatException("Number cannot be null/empty.");
		}
		
		// remove any leading or trailing spaces
		num = num.trim();
		final int size = num.length();
		
		// holds the starting position of the digits
		int index = 0;
		boolean isNegative = false;
		boolean hasDecimal = false;
		
		// check for unary operators
		char first = num.charAt(0);
		switch(first) {
			case '+':
				index++;
				break;
				
			case '-':
				index++;
				isNegative = true;
				break;
				
			case '.':
				index++;
				hasDecimal = true;
				break;
				
			default:
				throw new NumberFormatException("Number is malformed: " + num); 
		}
		
		// start the parsing logic
		
		double ip = 0.0, dp = 0.0;
		double fd = 1.0;
		
		for(int i = index; i < size; i++) {
			char c = num.charAt(i);
			int digit = c - '0';
			
			if(isNumeric(c) && digit != '0') {
				if(!hasDecimal) {
					ip *= 10;
					ip += digit;
				} else {
					dp *= 10;
					dp += digit;
					fd *= 10;
				}
			} else if(c == '.') {
				if(hasDecimal) {
					throw new NumberFormatException("Number is malformed: " + num);
				}
				
				hasDecimal = true;
			} else {
				throw new NumberFormatException("Number is malformed: " + num);
			}
		}
		
		// add the decimal fraction
		dp = dp / fd;
		double number = ip + dp;
		
		// test for negative
		if(isNegative) {
			number = 0 - number;
		}
		
		return number;
	}

	/**
	 * Tests whether the given character is a digit or not.
	 * 
	 * @param digit the character to be tested
	 * @return true if character is a digit, else false
	 */
	private static boolean isNumeric(char digit) {
		if('0' <= digit && digit <= '9') {
			return true;
		}
		
		return false;
	}
	
}

FRAG for Free Rice

2011-09-19T14:06:00.001+05:30

Free Rice is a site that helps one improve their English vocabulary (the first feature/section they rolled). Quite Simple, huh? No - for every word one gets right they donate 10 grains of rice to the World Food Programme to help end hunger. The cause itself along with the methodology they employ makes it a huge attraction. I am addicted to the game myself, but the professional commitments do not let me make the most of it.

Thus, I decided to use some of my skills to better use... and developed FRAG - Free Rice Avant Garde.

Frag as per Wikipedia is,

Frag is a computer and video game term originating from the word fragging, a term indicating to kill an unpopular superior officer with a fragmentation grenade. A frag is roughly equivalent to "kill", with the typical main difference that the player being "fragged" can instantly respawn (play again) in most games, i.e. the "kill" is only temporary

Avant Garde as per Wikipedia is,

Avant-garde means "advance guard" or "vanguard". The adjective form is used in English to refer to people or works that are experimental or innovative, particularly with respect to art, culture, and politics.

Thus, FRAGs is an automated bot that kills the hunger monster, by experimenting with technology where the arena relates to art and culture.

Simply, FRAGs for FreeRice is an automated bot that can play the game on your behalf. It comes with its own memory of answers, but is geared to keep building its memory as and when more questions are added to the game. It can play at a rate of 1 question every 3 seconds, thus accumulating 200 grains of rice every minute, or more than 0.25 million grains per day. Currently, the bot can play the following subjects,

Algebra
Capitals
English Vocabulary
Multiplication
Paintings
Periodic Table

The bot is written in Adobe AIR technology and demonstrates how one can interact between the HTML of a loaded page with ActionScript.

The source code for the bot is available on GitHub. A downloadable binary will be available soon.

Project Euler Problem 348 Solution

2011-09-07T13:21:00.000+05:30

Problem
Many numbers can be expressed as the sum of a square and a cube. Some of them in more than one way.

Consider the palindromic numbers that can be expressed as the sum of a square and a cube, both greater than 1, in exactly 4 different ways.
For example, 5229225 is a palindromic number and it can be expressed in exactly 4 different ways:

2285² + 20³
2223² + 66³
1810² + 125³
1197² + 156³

Find the sum of the five smallest such palindromic numbers.

Analysis
The given palindrome number is 7 digit. Hence, we start iterating with all palindromes that are atleast 7 digits in length and go up to the point where we find the first 5 palindromes satisfying the given condition. Finding palindromes iterating over a sequence is time consuming, hence, create a small function that generates only palindromes.

For a palindrome of digit length n, when n is even, a simple loop of n/2 digits can be run. Thus for palindromes of length 4, a loop from 10 to 99 can be run, where the number and its reverse are appended. Similarly for a palindrome of digit length n, when n is odd, a first loop for (n - 1)/2 digits and a second loop from 0 to 9 can be run. Thus for palindromes with a length 5, run an outerloop from 10 to 99 and an inner loop from 0 to 9. Concatenate the number, the middle element and the reverse of the number to generate the palindromes.

To check for the given condition that the number be expressed as a sum of square and cube, where both numbers are greater than 2. Simply run a loop from 2 to cube root of number minus 4 (for the square will be of atleast 2). Then see if the square root is perfect or not. Keep counting valid combinations. If a number has 4 such combinations consider it for the solution.

Solution
Code part of Project Maer on Github. Runs under 2 seconds in Java 6.

package com.sangupta.maer.page7;

import com.sangupta.maer.util.MathUtil;

/**
 * Problem 348 on Project Euler, http://projecteuler.net/index.php?section=problems&id=348
 *
 * @author Sandeep Gupta
 * @since 06-Sep-2011
 */
public class Problem348 {
	
	private static int found = 0;
	
	private static long sum = 0;

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		iterateOnPalindromes(7, 12);
		System.out.println("Sum: " + sum);
	}
	
	private static void iterateOnPalindromes(final int startDigits, final int maxDigits) {
		for(int numDigits = startDigits; numDigits <= maxDigits; numDigits++) {
			if(MathUtil.isEven(numDigits)) {
				long end = (long) Math.pow(10, (numDigits / 2));
				long start = end / 10;
				
				// loop
				for(long i = start; i < end; i++) {
					String palindrome = String.valueOf(i);
					palindrome = palindrome + new StringBuilder(palindrome).reverse().toString();
					boolean stopLoop = checkPalindrome(palindrome);
					if(stopLoop) {
						return;
					}
				}
			} else {
				// this is odd digit based
				int digitGroupLength = numDigits - 1;
				long end = (long) Math.pow(10, (digitGroupLength / 2));
				long start = end / 10;
				
				// loop
				for(long i = start; i < end; i++) {
					// the middle digit comes from the second loop
					for(int middle = 0; middle < 10; middle++) {
						String palindrome = String.valueOf(i);
						palindrome = palindrome + String.valueOf(middle) + new StringBuilder(palindrome).reverse().toString();
						boolean stopLoop = checkPalindrome(palindrome);
						if(stopLoop) {
							return;
						}
					}
				}				
			}
		}
	}

	/**
	 * @param palindrome
	 * @return
	 */
	private static boolean checkPalindrome(String palindrome) {
		Long number = Long.parseLong(palindrome);
		if(isPalindromeRepresentable(number)) {
			System.out.println("Found " + number);
			found++;
			sum += number;
		}
		
		if(found == 5) {
			return true;
		}
		return false;
	}

	private static boolean isPalindromeRepresentable(final long number) {
		int cubeLimit = (int) Math.cbrt(number - 4);
		
		int countForms = 0;
		
		for(int testNumber = 2; testNumber <= cubeLimit; testNumber++) {
			int cube = testNumber * testNumber * testNumber;
			long diff = number - cube;
			double squareRoot = Math.sqrt(diff);
			int intSquareRoot = (int) squareRoot;
			if(squareRoot == intSquareRoot) {
				countForms++;
			}
		}
		
		if(countForms == 4) {
			return true;
		}
		
		return false;
	}
}

Magic of flash.trace.Trace

2011-08-03T14:47:00.001+05:30

One of the hidden treasures in the Flash Player is the flash.trace.Trace class. It was meant to be hidden, but in open-source nothing can be treasured without the world knowing it. The actual class implementation is available in the tamarin-central codebase. An excerpt of the class implementation is as under (copyright notices etc removed),

package flash.trace
	public class Trace
	{
		/* levels of desired logging */
		public static const OFF:int = 0;
		public static const METHODS:int = 1;						// method entry only 
		public static const METHODS_WITH_ARGS:int = 2;				// method entry and arguments
		public static const METHODS_AND_LINES:int = 3;				// method entry and line numbers
		public static const METHODS_AND_LINES_WITH_ARGS:int = 4;	// method entry, arguments and line numbers

		/* used to select either file or listener callback logging. */
		public static const FILE = 1;
		public static const	LISTENER = 2;

		public static native function setLevel(l:int, target:int=LISTENER);
		public static native function getLevel(target:int=LISTENER):int;

		/**
		 * Register a listener to receive trace callbacks upon method and/or 
		 * line number changes.  Passing null to this function effectively
		 * 'unregisters' the listener and only a single listener can 
		 *  be specified.
		 * 
		 *  The callback funcition must have the following signature:
		 *
		 *     function foo(file_name:String, linenum:int, method_name:String, method_args:String):void
		 *
		 *  Depending upon the setting of the trace level, 2 or more arguments may be non-empty.  
		 *  In all cases file_name and method_name are obtained and passed to the callback.  If 
		 *  the trace level include line numbers information then this value is also obtained 
		 *  and passed into the callback.  Setting the trace level to include method arguments implies
		 *  that the 'method_args' parameter will be filled with string representation of the arguments
		 *  passed into the call.
		 */
		public static native function setListener(f:Function);
		public static native function getListener():Function;
	};
};

Harnessing the power of the same in ActionScript is easy. The magic lies in the fact that for every executed line, the listener as provided in the class above would be called, giving out the class name, the method name, the file name, and yes, the method arguments as well. Don't believe it. Try it.

The following class is a wrapper over the flash.trace.Trace class to see the code execution between two points.

package com.sangupta.utils
{
	import flash.trace.Trace;

	public class TraceUtility {
		
		private static var init:Boolean = false;
		
		private static var linesExecuted:uint = 0;
		
		public function TraceUtility() {
			super();
		}
		
		public static function startTracing():void {
			if(!init) {
				Trace.setListener(traceListener);
				init = true;
			}
			
			Trace.setLevel(Trace.METHODS_AND_LINES_WITH_ARGS, Trace.LISTENER);
		}
		
		public static function stopTracing():void {
			Trace.setLevel(Trace.OFF, Trace.LISTENER);
			trace('Total lines executed: ' + linesExecuted);
			linesExecuted = 0;
		}
		
		private static function traceListener(fileInfo:String, lineNumber:String, classAndMethod:String, methodArguments:String):void {
			linesExecuted++;
			trace(classAndMethod + '(' + methodArguments + ')'); 
		}
	}
}

Usage is simple in a class, say, MyWorker:

package com.sangupta.utils
{
	import TraceUtility;

	public class TraceUtilityTest {
		
		public function myWorkingMethod():void {
			TraceUtility.startTracing();

			// do something expensive here

			TraceUtility.stopTracing();
		}
		
	}
}

Notes: First, as for every executed line the listener is called, this will slow down the execution of the code. Second, this is not meant to replace the Application Profiling workflows. Lastly, in a nutshell, this technique should not be used in releasable code.

Hope this helps.

Agam | Adobe Flash Platform Summit

2011-08-02T18:10:00.001+05:30

I recently had the chance of attending my first Adobe Flash Platform Summit. The whole experience was just awesome, and this I say not because I am currently with Adobe, but for the wealth of information, tips and tricks, demos and tutorials, the evangelist team shared. The sessions had packed a lot of information, which to grasp in the given time frame was difficult. Add to it the magical Bangalore weather and the tasty south indian dishes for lunch, my experience enhances many a folds.

Anyways, this post is not about the shared information (there will be more later), but about the best time and/or session, we had in the summit. To disappoint all the geeks, what am I talking of is
the live performance of the contemporary carnatic rock band, Agam. What made it more enjoyable was the fact that all group members are engineers of the IT industry (gosh, where do they find time from) from companies like Adobe, Yahoo! and more.

More on Agam in their own words,

GENRES
Rock / Carnatic / Experimental

LOCATION
Bangalore, IN

MEMBERS
Harish - Vox
Ganesh - Drums
Praveen & Suraj - Guitars
Vignesh - Bass
Shiva - Percussions
Swamy - Keys

The groups site features all their songs ready to be enjoyed. I will recommend Brahma's Dance to one and all.

Next is the snapshot of the memoirs I will always cherish.

Go and enjoy some good music. Thanks Agam!

In-Place Character Array Compression

2011-07-14T08:00:00.000+05:30

Problem: Given a character stream as an array, compress the characters in place appending the number of continuous characters by the numerical value and then the character. The array is terminated by a 0x00 character.

Solution: Another classic interview problem which tests multiple skills in a single problem, namely,

Conversion from integer to ascii - the number returned is a integral value which needs to be converted to ascii and then put in place in stream
Skills with pointers (not the real pointers) when operating on an array

The following JAVA code illustrates how to work up the given problem. It makes use of an itoa() method that was explained before here.

package com.sangupta.keepwalking;

public class CharacterArrayCompression {

	public static void main(String[] args) {
		String stream = "aaaaaaaaaaaaaaaaaaaaabbbbbbssssskkkkjkkdkksdkkkdeeeekkllsssiii";
		char[] characters = stream.toCharArray();
		compress(characters);
		System.out.println(characters);
	}

	private static void compress(char[] characters) {
		if(characters == null || characters.length <= 1) {
			// do nothing if we are not provided with any data
			// or if we have a single character
			return;
		}
		
		char current = characters[0];
		int count = 1;
		int destination = 0;
		for(int index = 1; index < characters.length; index++) {
			char found = characters[index];
			if(current == found) {
				count++;
			} else {
				// compress and store the value
				if(count > 1) {
					char[] value = IntegerToAscii.itoa(count);
					for(int j = 0; j < value.length; j++) {
						char temp = value[j];
						if(temp != '\0') {
							characters[destination++] = temp;
						}
					}
				}
				characters[destination++] = current;
				
				// reset to the new occurence of character
				current = found;
				count = 1;
			}
		}
		
		for(int index = destination; index < characters.length; index++) {
			characters[index] = '\0';
		}
	}

}

Happy Coding!

Make Sharing Easy

2011-07-13T15:34:00.000+05:30

Yesterday a very dear friend of mine, Rajat Ahuja suggested me to add a Facebook Like or a Google +1 button to the blog so that sharing becomes easy. As this was something I had turned off a while back, bringing it in was not so tough. Hence, from just now all over my blog the following 3 buttons will appear along with the usual ReTweet button,

Facebook Like button
Google Buzz button
Google +1 button

I might turn off the Google Buzz button, again, due to my personal aversion to its color combination :)

Thanks a lot, Rajat for suggestion.

In-Place Character Array Encoding

2011-07-13T08:19:00.000+05:30

Problem: Given a character stream as an array, encode the characters in place replacing given set of characters by their 3-character equivalent. The array is terminated by a 0x00 character. If the array cannot be fully encoded, the array should not be modified.

Solution: This is a classic interview problem. There are two aspects to this problem,

Calculating whether the array would be able to contain the entirely encoded string. This can be easily achieved by calculating the length of the string, the number of encodable characters and the size of the array. If the free space in the array is equal to the additional capacity that would be needed by the encodable characters

Encode the string from tail than from head. This is a must so that one does not override the characters ahead, when an encodable character is written encoded in the string.

A simple JAVA implementation is shown below.

/**
 * Copyright (C) 2010-2011, Sandeep Gupta
 * http://www.sangupta.com
 * 
 * The file is licensed under the the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * 
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * 
 */

package com.sangupta.keepwalking;

import java.util.Arrays;

/**
 * Class to encode a given character stream (defined as char[] array). The character array is the only
 * memory space one has. In case encoding is not possible, the array should be left untouched. The array
 * will be terminated by a null to indicate string termination.
 * 
 * Each encodable character is 3 characters in length. Thus, additional space required would be 2 characters
 * per each encodable character.
 * 
 * @author sangupta
 * @since 12 July 2011
 */
public class CharacterStreamEncoder {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		char[] stream = new char[12];
		Arrays.fill(stream, '\0');
		stream[0] = 's';
		stream[1] = 'a';
		stream[2] = 'n';
		stream[3] = 'd';
		stream[4] = ' ';
		stream[5] = ' ';
		stream[6] = 'p';
		
		boolean result = encode(stream);
		if(result) {
			System.out.println(stream);
		} else {
			System.out.println("String was not modified.");
		}
	}
	
	public static boolean encode(char[] stream) {
		final int streamLength = stream.length;
		System.out.println("Total length: " + streamLength);
		
		// first we need to check if we can encode the string or not
		// in the given only space
		// so we read each character and count the total number of encodable
		// characters and also the length of the string.
		int encodable = 0;
		int length = 0;
		for(int index = 0; index < stream.length; index++) {
			char temp = stream[index];
			if(temp == '\0') {
				break;
			} else {
				length++;
				if(isEncodable(temp)) {
					encodable++;
				}
			}
		}
		
		System.out.println("Length of string: " + length);
		System.out.println("Encodable: " + encodable);
		
		if(encodable == 0) {
			return true;
		}
			
		// now check for the balance length
		int balance = streamLength - length;
		if(encodable *2 >= balance) {
			// not sufficient space in stream to encode
			return false;
		}
		
		// now we start from the end of the stream to encode
		// so that we do not override the characters before
		// as we already know the number of encodable characters
		// we know where the last character would be written
		int destination = length + encodable * 2 - 1;
		int source = length;
		
		for(int index = source; index > 0; index--) {
			char character = stream[index - 1];
			char[] encoded = encode(character);
			if(encoded.length == 1) {
				stream[destination--] = encoded[0];
			} else {
				// we need to set the 3 character bytes properly
				stream[destination--] = encoded[2];
				stream[destination--] = encoded[1];
				stream[destination--] = encoded[0];
			}
		}
		
		return true;
	}

	private static boolean isEncodable(char character) {
		switch(character) {
			case ' ':
				return true;
				
		}
		
		return false;
	}
	
	private static char[] encode(char character) {
		switch(character) {
			case ' ':
				return new char[] { '%', '2', '0' };
		}
		
		return new char[] { character };
	}

}

Java 7: Enhanced Syntax for Numeric Literals

2011-07-12T16:06:00.000+05:30

As far as I know, Java never updated the syntax for defining integral constants since JDK 1.2, which seems like ages before. To end that drought, Java 7 defines enhanced syntax for the following,

Numeric constants expressed as binary
Suffix to denote type as short or byte
Improved readability by use of underscores in integer constants

The above enhancements do not impact a seasoned developer much, nor they provide something out-of-this-world. The only benefit you get is improved readability and vanishing of minor hiccups when coding.

Binary Values

Before Java 7, in order to parse binary values one would write,

int value = Integer.parseInt("10101010", 2);

This in addition to some extra code, also has performance impact besides making the value as a runtime constant than compile time constant. Thankfully, Java 7 introduces the concept of 0b on the same lines as 0x for hexa-decimal values. Thus, the above code fragment in Java 7 would become,

int value = 0b10101010;

The value is now a compile time constant and also, has no performance hit.

Short and Byte values

Java had several integral types such as short and byte, but no syntactical way to code the values directly in, as all numerical constant were treated as integers. Type-casting led to annoyance and discomfort during code and might also have led to limit-over-runs. With Java 7, assigning values for these integral types becomes easy as,

byte b = 245y;

and,

short s = 65535s;

The above values just provide some syntactical sugar when coding and improves readability.

Underscores in values

A long binary, hexa-decimal or integral value becomes hard to read by human mind. If the number of digits increase figuring out the exact extant of the value at times gets difficult. Java 7 adds some real beauty for such use-cases by adding support to add underscores to integral values for improved readability. Thus a value of 2 GB, 2147483648 now may be expressed as,

long twoGigabytes = 2_147_483_648L;

In my honest opinion, this is definitely a boon for mathematical and statistical developers who really had tough time understanding someone's else code... err.. defined constants.

Hope this helps me, more than anyone else in remembering the new sugars! Happy Coding!

Intermittent error establishing connection with Spring, Hibernate and C3P0

2011-07-11T12:14:00.000+05:30

Most of the Java web projects (and desktop projects as well) use the well known Spring and Hibernate frameworks. I myself have been using them for over 6 years now, and must say, the benefits they have provided have been immense, both in terms of rapid application development, testing and of course, maintenance. With good amount of experience in using the both I rarely find it difficult debugging a bug, but sometimes, I have come across issues that have been both time-consuming and have thrown open unleashed areas of the frameworks. Recently, I happened to land debugging one such issue.

When running are project, which uses HibernateTemplate to simplify access to the data layer, we saw intermittent timeout issues. The intermittent failures in them self were very strange. Running from a machine with query latency of around 10 seconds, only once reproduced the issue. Running from a machine with 2.5 second latency, the issue was 25% reproducible, and from a machine with just 1 second latency (quite close to DB datacenter) never reproduced the issue.

Our application configuration was pretty simple, Spring 2.5.6 working in tandem with Hibernate 2.4, using C3P0 as the connection pool. Good stack, right?

There were two Java exceptions which were coming up randomly, as,

org.hibernate.util.JDBCExceptionReporter

No suitable driver found for jdbc:oracle:thin:@myDomain:myPort/mySchemaName

and,

org.springframework.dao.DataAccessResourceFailureException: Hibernate operation: Cannot open connection; SQL [???]; 
Io exception: The Network Adapter could not establish the connection; nested exception is,
 java.sql.SQLException: Io exception: The Network Adapter could not establish the connection
	at org.springframework.jdbc.support.SQLErrorCodeSQLExceptionTranslator.doTranslate(SQLErrorCodeSQLExceptionTranslator.java:236)
	at org.springframework.jdbc.support.AbstractFallbackSQLExceptionTranslator.translate(AbstractFallbackSQLExceptionTranslator.java:72)
	at org.springframework.orm.hibernate3.HibernateAccessor.convertJdbcAccessException(HibernateAccessor.java:424)
	at org.springframework.orm.hibernate3.HibernateAccessor.convertHibernateAccessException(HibernateAccessor.java:410)
	at org.springframework.orm.hibernate3.HibernateTemplate.doExecute(HibernateTemplate.java:424)
	at org.springframework.orm.hibernate3.HibernateTemplate.execute(HibernateTemplate.java:339)
	at java.util.concurrent.FutureTask$Sync.innerRun(FutureTask.java:303)
	at java.util.concurrent.FutureTask.run(FutureTask.java:138)
	at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:886)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:908)
	at java.lang.Thread.run(Thread.java:662)
Caused by: java.sql.SQLException: Io exception: The Network Adapter could not establish the connection
	at oracle.jdbc.driver.DatabaseError.throwSqlException(DatabaseError.java:145)
	at oracle.jdbc.driver.DatabaseError.throwSqlException(DatabaseError.java:190)
	at oracle.jdbc.driver.DatabaseError.throwSqlException(DatabaseError.java:363)
	at oracle.jdbc.driver.T4CConnection.logon(T4CConnection.java:401)
	at oracle.jdbc.driver.PhysicalConnection.(PhysicalConnection.java:441)
	at oracle.jdbc.driver.T4CConnection.(T4CConnection.java:165)
	at oracle.jdbc.driver.T4CDriverExtension.getConnection(T4CDriverExtension.java:35)
	at oracle.jdbc.driver.OracleDriver.connect(OracleDriver.java:839)
	at java.sql.DriverManager.getConnection(DriverManager.java:582)
	at java.sql.DriverManager.getConnection(DriverManager.java:154)
	at org.springframework.jdbc.datasource.DriverManagerDataSource.getConnectionFromDriverManager(DriverManagerDataSource.java:174)
	at org.springframework.jdbc.datasource.DriverManagerDataSource.getConnectionFromDriver(DriverManagerDataSource.java:165)
	at org.springframework.jdbc.datasource.AbstractDriverBasedDataSource.getConnectionFromDriver(AbstractDriverBasedDataSource.java:149)
	at org.springframework.jdbc.datasource.AbstractDriverBasedDataSource.getConnection(AbstractDriverBasedDataSource.java:119)
	at org.springframework.orm.hibernate3.LocalDataSourceConnectionProvider.getConnection(LocalDataSourceConnectionProvider.java:82)
	at org.hibernate.jdbc.ConnectionManager.openConnection(ConnectionManager.java:417)
	at org.hibernate.jdbc.ConnectionManager.getConnection(ConnectionManager.java:144)
	at org.hibernate.jdbc.AbstractBatcher.prepareQueryStatement(AbstractBatcher.java:139)
	at org.hibernate.loader.Loader.prepareQueryStatement(Loader.java:1560)
	at org.hibernate.loader.Loader.doQuery(Loader.java:661)
	at org.hibernate.loader.Loader.doQueryAndInitializeNonLazyCollections(Loader.java:224)
	at org.hibernate.loader.Loader.doList(Loader.java:2144)
	at org.hibernate.loader.Loader.listIgnoreQueryCache(Loader.java:2028)
	at org.hibernate.loader.Loader.list(Loader.java:2023)
	at org.hibernate.loader.custom.CustomLoader.list(CustomLoader.java:289)
	at org.hibernate.impl.SessionImpl.listCustomQuery(SessionImpl.java:1695)
	at org.hibernate.impl.AbstractSessionImpl.list(AbstractSessionImpl.java:142)
	at org.hibernate.impl.SQLQueryImpl.list(SQLQueryImpl.java:150)
	at org.springframework.orm.hibernate3.HibernateTemplate.doExecute(HibernateTemplate.java:419)
	... 15 more

Obviously the ERROR 1 listed above was nothing related, as the code had obtained DB connections (for sure). The ERROR 2 indicated that we were opening more connections than what the database could handle. We tried setting up a local database and tested the whole code, but the error won't reproduce. We thus concluded (only to be proven wrong later) that the database was unable to handle the load of our connections (a connection pool of 100 connections). We lowered our throttle of hitting to 50, 20, 10, and lastly 5 connections but the error still occurred on the staging and production servers. We contacted the database team and they informed that there were more than enough free handles on the database side and no alert was raised for DB going overboard the total number of allowed connections.

This made us change our mind to think that there was some connectivity issues with the stating/production machines, both being in the same datacenter. We tested heavily both the machines but found nothing that suggested a connectivity issue. Again we stood at a blank wall.

We again went back to the DB team to help us debug. As one another test, we ran our code in the DBA presence monitoring the database. The DBA informed that we were creating connections at a rapid pace, creating them, firing a query, and then disconnecting. Voila! What was that - we were using a connection pool. Was it not working?

We went back to the code and ran the profiler along with netstats. This confirmed that we were creating DB connections and then dropping for every single query. But why should that happen, when we were for sure, using C3P0 (shipped with Hibernate) for our connection pooling. After deep penetration into the code, we figured out that firing plain SQL queries using Hibernate template does not makes use of the inherent connection pool of Hibernate. This broke all our code - we were using the HibernateTemplate extensively in our application and firing native queries (why so - leaving as it calls for another detailed post) over the MySQL database.

As a quick fix, we added Apache Commons DBCP connection pooling layer over our data-source. This made our stack look something like,

DB -> Apache DBCP DataSource -> Hibernate -> C3P0 -> Spring -> Our application

.
This seemed to do the trick. Not only did the connection fetch failure vanished, we also saw improved performance gains with connection pooling (as if we didn't knew).

As they say, better late than never - we could fix the problem well before the release, burning some mid-night...err... mid-day oil. But this taught me a lesson,

Always profile your application for connections before releasing.

.
Hope this helps someone out there having a similar problem. You do, try this and if it gets resolved, drop in a comment.

Time For Change

2011-07-06T20:14:00.000+05:30

They say,

Change is the only constant.

How true this is, we realize as we keep walking down the lane of our life.

Today, happens to be one such change. Today, I have started migrating all code from various repositories that held my code, such as Source Forge, Google Code and other locally hosted ones, to their new home - Github.

This is one single consolidation effort where in I want all my code to be available publicly, be of good quality and above all - clean up my systems. Keeping their backups have already become nightmare for me. I anticipate this to take around 2 weeks, so keep watching for more posts under the label, myjerry.

Stay tuned, for more blog posts on how to reuse all this shit of code ;)

Keep Walking!

Java 7: String switching

2011-06-29T21:33:00.000+05:30

Today, I started my journey into the world of Java 7. Quite late I know, but as they better late than never. So I now have a build of Java 7 SDK on my desktop, and spent some time fiddling with the new features in. One of the most striking features of Java 7, specially after working in ActionScript 3, is the ability to switch on strings.

ActionScript developers would know the value and power of this small feature, as it gets rid of those ugly multiple if-else if-else if-else blocks. One way to fool around was to use Enums but that to me seemed overkill specifically if the input data was coming from a file, database or human interface.

Thus, what looked like in the Java world till Java 6

public void someMethod(String command) {
    if("dir".equals(command)) {
        // list the files in folder
    } else if("cls".equals(command)) {
        // clear the screen
    } else if("rename".equals(command)) {
        // rename the given file
    } else if("delete".equals(command)) {
        // delete the given file
    } else if("ver".equals(command)) {
        // display OS version
    } else {
        throw new IllegalArgumentException("Command not found.");
    }
}

has now been reduced to something like,

public void someMethod(String command) {
    switch(command) {
        case "dir":
            // list file in folder
            break;

        case "cls":
            // clear the screen
            break;

        case "rename":
            // rename the given file
            break;

        case "delete":
            // delete the given file
            break;

        case "ver":
            // display OS version
            break;

        default:
            throw new IllegalArgumentException("Command not found.");
    }
}

Foshizle, it is not a super-developer-feature that may make you say a WOW, but it surely would make some pieces of code readable, and easily debug-able.

Happy Coding!