Keep Walking!

Change Eclipse Juno UI to match Eclipse Indigo

2012-08-13T09:53:00.000+05:30

Some of the Windows users, like me, who have switched to Eclipse Juno (Eclipse 4.2) might not have liked the theme that ships as default. Specially, the piece around the toolbar backgrounds, the code editing theme, the absence of left border along side line numbers, and the overtly flashy UI containers.

To put in plain simple words: Eclipse Juno theme actually sucks. All the hype around CSS based styling might be very good technically, and a step forward, but per UX standards it sucks, and it sucks hard.

But we have a quick workaround: For those who wish to move to using the Eclipse Indigo looks, a version prior, simply, rename the folder,

plugins\org.eclipse.platform_4.2.0.v201206081400\css

to something like,

plugins\org.eclipse.platform_4.2.0.v201206081400\css.old

And you are done! Launch your eclipse and enjoy the old theme.

Note: Make sure Eclipse is not-running when making this change.

Hope this helps.

Pepmint now in Maven Central

2012-07-28T11:46:00.001+05:30

I am pleased to announce the immediate availability of Pepmint, a Java wrapper over the Python Pygments library in Maven Central. Use the following to include it as a dependency,

<dependency>
    <groupId>com.sangupta</groupId>
    <artifactId>pepmint</artifactId>
    <version>1.1.2</version>
</dependency>

For more information on usage, visit the project page at http://www.sangupta.com/projects/pepmint

Saving HTML5 canvas to Java server

2012-07-12T14:10:00.000+05:30

If you are working with HTML5 Canvas element and are looking to save the generated PNG file back on to the server via Java - it is not as easy as saving the byte array. The reason that the generated PNG data is URL encoded and is prefixed with the dataURI format headers.

    var canvas = document.getElementById('#myCanvas');
    var pngData = canvas.toDataURL('image/png');

The following code will convert the raw bytes by stripping off the headers, and coverting the Base64 encoded data to the raw PNG bytes.

private void saveImage(byte[] pngData) {
 String png = new String(pngData);
 String find = "base64%2C";
 String tokens = png.substring(png.indexOf(find) + find.length());
 String decoded = StringUtils.replace(tokens, "%2F", "/");
 byte[] bytes = new Base64Encoder().decode(decoded);

 // save the generated bytes
 // which can then be read in a BufferedImage
 BufferedImage image = ImageIO.read(new ByteArrayInputStream(bytes));
 
 // mroe code
}

Hope this helps.

Trim down HTML content to desired text length

2012-07-11T13:18:00.000+05:30

Problem: Given some HTML code, trim it down into valid HTML code that contains text of desired length.

For example:

String s1 = "Text with bold, italic phrases.";
String s2 = trimHTML(s1, 12);
System.out.println(s2);

should return

Text with bo

Solution: For a project of mine, I had to use such a functionality. A quick google did not result in any existing function, and thus I ended up coding the following:

/**
 * Strip the given HTML content to specified text length. All opening
 * tags are then closed to make sure that the HTML is perfectly safe.
 * 
 * Tags such as br are skipped for closing.
 * 
 * @param content the HTML content that you want to trim down
 * @param length the desired length of the text field
 * @return the HTML code that contains text trimmed down to said length
 */
public static String trimHTML(String content, int length) {
 int currentIndex = 0;
 int chosenTextLength = 0;
 String tag;
 Stack tags = new Stack();
 do {
  int index = content.indexOf('<', currentIndex);
  if(index > currentIndex) {
   chosenTextLength += (index - currentIndex - 1);
   currentIndex = index;
  }
  
  if(chosenTextLength >= length) {
   break;
  }
  
  if(index != -1) {
   index = content.indexOf('>', index);
   tag = content.substring(currentIndex + 1, index);
   if(!tag.startsWith("/")) {
    if(tag.endsWith("/")) {
     tag = tag.substring(0, tag.length() - 1);
    }
    
    tags.push(tag.trim());
   } else {
    tag = tag.substring(1);
    do {
     if(tags.size() == 0) {
      break;
     }
     
     String pop = tags.pop();
     if(pop.equalsIgnoreCase(tag)) {
      break;
     }
    } while(true);
   }
   
   currentIndex = index;
  }
  
  if(index == -1) {
   break;
  }
 } while(true);
 
 if(chosenTextLength > length) {
  int subtract = chosenTextLength - length;
  currentIndex = currentIndex - subtract;
 }
 
 if(tags.size() == 0) {
  return content.substring(0, currentIndex);
 }
 
 StringBuilder builder = new StringBuilder(content.substring(0, currentIndex));
 int size = tags.size();
 for(int index = 0; index < size; index++) {
  tag = tags.pop();
  
  if(!"br".equalsIgnoreCase(tag)) {
   builder.append("');
  }
 }
 
 return builder.toString();
}

The code is also available under the Jerry project. You may browse the latest edition of this utility function in the GitHub repository in HtmlUtils.java file.

Merge different SCM snapshots

2012-05-04T15:09:00.001+05:30

This post is about MergeRepo a small script that allows to merge two different snapshots of the same repository from different SCMs into one.

Recently, I had to collaborate on a project where the code was in Subversion. As we usually use Perforce, we forked a copy of the SVN trunk into Perforce and started our development. Once, the development was complete, we wanted to merge back in Subversion. And now, the nightmare started. SVN showed all files (thousands) to have been modified, due to a change in the timestamp or the change in line-ending character.

The issue with line-ending character was easier to resolve, but the change in timestamp still created havoc. Thus, the need for this tool emerged. I wrote this simple script to ignore timestamp, and EOL character, and merge the removed/added/modified files back into the SVN folder, so that only such files were shown for commit.

The tool allows us to resolve such situations. It compares the two snapshots (folders/trees) and generates the merged repository with the only the modified files, so that it can be checked back into the original line. The tool can be used as,

Usage:    $ java com.sangupta.keepwalking.MergeRepo <previous> <newer> <destination>

          previous      The folder corresponding to the older repository snapshot.
          newer         The folder corresponding to the newer repository snapshot.
          destination   The folder where the updated repository will be created.

The source code for the same is available on my GitHub repository, or below.

/**
 *
 * MergeRepo - allows to merge two different snapshots of the same repository
 * Copyright (c) 2012, Sandeep Gupta
 * 
 * Read more at http://blog.sangupta.com
 * 
 * Licensed under 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.io.File;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import org.apache.commons.io.FileUtils;
import org.apache.commons.io.filefilter.FileFilterUtils;
import org.apache.commons.io.filefilter.IOFileFilter;
import org.apache.commons.io.filefilter.TrueFileFilter;

/**
 * Allows to merge two different snapshots of the same repository which are checked
 * in to two different SCM versions.
 *
 * @author sangupta
 */
public class MergeRepo {

 /**
  * @param args
  * @throws IOException 
  */
 public static void main(String[] args) throws IOException {
  if(args.length != 3) {
   usage();
   return;
  }
  
  final String previousRepo = args[0];
  final String newerRepo = args[1];
  final String mergedRepo = args[2];
  
  final File previous =  new File(previousRepo);
  final File newer = new File(newerRepo);
  final File merged = new File(mergedRepo);
  
  if(!(previous.exists() && previous.isDirectory())) {
   System.out.println("The previous version does not exists or is not a directory.");
   return;
  }
  
  if(!(newer.exists() && newer.isDirectory())) {
   System.out.println("The newer version does not exists or is not a directory.");
   return;
  }
  
  final IOFileFilter directoryFilter = FileFilterUtils.makeCVSAware(FileFilterUtils.makeSVNAware(null));
  
  final Collection<File> olderFiles = FileUtils.listFiles(previous, TrueFileFilter.TRUE, directoryFilter);
  final Collection<File> newerFiles = FileUtils.listFiles(newer, TrueFileFilter.TRUE, directoryFilter);

  // build a list of unique paths
  System.out.println("Reading files from older version...");
  List<String> olderPaths = new ArrayList<String>();
  for(File oldFile : olderFiles) {
   olderPaths.add(getRelativePath(oldFile, previous));
  }

  System.out.println("Reading files from newer version...");
  List<String> newerPaths = new ArrayList<String>();
  for(File newerFile : newerFiles) {
   newerPaths.add(getRelativePath(newerFile, newer));
  }
  
  
  // find which files have been removed from Perforce depot
  List<String> filesRemoved = new ArrayList<String>(olderPaths);
  filesRemoved.removeAll(newerPaths);
  System.out.println("Files removed in newer version: " + filesRemoved.size());
  for(String removed : filesRemoved) {
   System.out.print("    ");
   System.out.println(removed);
  }
  
  // find which files have been added in Perforce depot
  List<String> filesAdded = new ArrayList<String>(newerPaths);
  filesAdded.removeAll(olderPaths);
  System.out.println("Files added in newer version: " + filesAdded.size());
  for(String added : filesAdded) {
   System.out.print("    ");
   System.out.println(added);
  }
  
  // find which files are common 
  // now check if they have modified or not
  newerPaths.retainAll(olderPaths);
  List<String> modified = checkModifiedFiles(newerPaths, previous, newer);
  System.out.println("Files modified in newer version: " + modified.size());
  for(String modify : modified) {
   System.out.print("    ");
   System.out.println(modify);
  }
  
  // clean any previous existence of merged repo
  System.out.println("Cleaning any previous merged repositories...");
  if(merged.exists() && merged.isDirectory()) {
   FileUtils.deleteDirectory(merged);
  }
  
  System.out.println("Merging from newer to older repository...");
  // copy the original SVN repo to merged
  FileUtils.copyDirectory(previous, merged);
  
  // now remove all files that need to be
  for(String removed : filesRemoved) {
   File toRemove = new File(merged, removed);
   toRemove.delete();
  }
  
  // now add all files that are new in perforce
  for(String added : filesAdded) {
   File toAdd = new File(newer, added);
   File destination = new File(merged, added);
   FileUtils.copyFile(toAdd, destination);
  }
  
  // now over-write modified files
  for(String changed : modified) {
   File change = new File(newer, changed);
   File destination = new File(merged, changed);
   destination.delete();
   FileUtils.copyFile(change, destination);
  }
  
  System.out.println("Done merging.");
 }
 
 private static void usage() {
  System.out.println("RepoMerge: Command-line tool to merge two snapshots of a single repositories that come from ");
  System.out.println("           different sources. Like you have your older repository in SubVersion and the newer");
  System.out.println("           code in Perforce. Now you want to merge the code and bring SVN back to the level of");
  System.out.println("           Perforce.");
  System.out.println("");
  System.out.println("Usage:    $ java com.sangupta.keepwalking.MergeRepo <previous> <newer> <destination>");
  System.out.println("");
  System.out.println("          previous      The folder corresponding to the older repository snapshot.");
  System.out.println("          newer         The folder corresponding to the newer repository snapshot.");
  System.out.println("          destination   The folder where the updated repository will be created.");
 }

 /**
  * Checks if the file with given path is different in two different folders/branches
  *  
  * @param commonPath
  * @param svn
  * @param perforce
  * @return
  * @throws IOException
  */
 private static List<String> checkModifiedFiles(List<String> commonPath, File svn, File perforce) throws IOException {
  List<String> changed = new ArrayList<String>();
  
  for(String filePath : commonPath) {
   File svnFile = new File(svn, filePath);
   File perforceFile = new File(perforce, filePath);
   
   boolean equal = FileUtils.contentEqualsIgnoreEOL(svnFile, perforceFile, Charset.defaultCharset().name());
   if(!equal) {
    changed.add(filePath);
   }
  }
  
  return changed;
 }

 /**
  * Extract the relative path of the file from the absolute path, given the parent.
  * 
  * @param file
  * @param parent
  * @return
  */
 private static String getRelativePath(File file, File parent) {
  String path = file.getAbsolutePath();
  String parentPath = parent.getAbsolutePath();
  if(path.startsWith(parentPath)) {
   return path.substring(parentPath.length() + 1);
  }
  
  return path;
 }

}

Hope it helps, some one out there!

Introducing as3dribbble - ActionScript Client Library for Dribbble.com

2012-04-28T13:12:00.002+05:30

I am happy to announce the availability of as3dribbble, an ActionScript client library for working with Dribbble.com APIs. The library is strongly-typed, pagination-aware, and rate-limit aware for accessing all the current APIs. The library also exposes a convenience class called DribbbleInvoker that may be used to add more APIs (should they get added in future and this library looses track). The invoker is rate-limit safe.

Usage

A simple example to use is as under,

private function getShotDetails():void {
    var client:DribbbleClient = new DribbbleClient();

    // the requestID can then be used to check which request failed
    var requestID:uint = client.getShot(12, showShot, errorHandler);
}

private function showShot(shot:Shot):void {
    trace('received shot details: ' + shot);
}

private function errorHandler(id:uint):void {
    // error occured when fetching shot details
}

Pagination Support

All API methods that support pagination have a corresponding, pagination-aware method available as well. For example, when fetching comments for a shot you may do,

var client:DribbbleClient = new DribbbleClient();

private function getShotComments():void {
    var requestID:uint = client.getShotComments(123, showComments, errorHandler);
}

private function showComments(list:CommentList):void {
    // do something with these comments

    var requestID:uint;

    // check for more comments
    if(list.getPage() < list.getPages()) {
        // fetch results from page 2
        requestID = client.getShotComments(1, showComments, errorHandler, 2);

        // or, may provide the number of results to fetch as well
        // fetch results from page 2, with 15 results per page
        requestID = getShotComments(1, showComments, errorHandler, 2, 15);
    }
}

The current default for number of results per page is 15 per Dribbble API. Refer http://dribbble.com/api for more details.

Rate-Limiting and Exceptions

By default, the DribbbleClient will throw a DribbbleApiRateLimitException run-time error when the request rate goes over the board. This makes sure that your client does not need to catch unnecessary exceptions during invocation. In case you wish, you may catch this exception and delay the request to a future time as,

private function getShot():void {
    var shot:Shot = null;
    var shotID:uint = 1;

    try {
        var requestID:uint = client.getShot(shotID, showShot, errorHandler);
    } catch(e:DribbbleApiRateLimitException) {
        // wait for a minute
        setTimeOut(getShot, 1000 * 60); // call again after a minute
    }
}

If you wish to prevent the code from throwing the DribbbleApiRateLimitException exception, you can do so when creating the client.

var client:DribbbleClient = new DribbbleClient(false);

Any invocations on this client, will not throw the error, but return a null back as the result to the completion handler you specified.

Dependencies

The library does not depend on any third-party libraries and is self-contained. The library has been compiled and tested using Adobe Flex 4.6/Adobe AIR 3.0.

Project Links

More details on the project can be found on project home page, http://www.sangupta.com/projects/as3dribbble.
Source Code: https://github.com/sangupta/as3dribbble
Downloads: https://github.com/sangupta/as3dribbble/downloads
Issue Management: https://github.com/sangupta/as3dribbble/issues
Usage Instructions: https://github.com/sangupta/as3dribbble/blob/master/README.md

Keep Dribbbling!

Introducing Pepmint!

2012-04-23T15:27:00.001+05:30

I am happy to introduce PepMint, a JAVA wrapper over the awesome Python's Pygments code syntax highlighting library. With Pepmint you can easily syntax highlight your own piece of snippet using code. This essentially helps us to build tools that consume code and output HTML - blog engines, presentation tools, documentation generators etc.

Usage

Super-easy way to use the library is described in the example below,

public String highlight(String code, String language) {
    Pepmint pepmint = null;
    Lexer lexer = pepmint.newLexer(format);
    Formatter formatter = pepmint.newHtmlFormatter(formatterParams);

    String formattedCode = pepmint.highlight(code, lexer, formatter);
    return formattedCode;
}

Dependencies

The library is self-contained and does not depend on any third-party library. It is built using,

Java 1.6
Jython 2.5.6
Pygments 1.4

Project Links

More details on the project can be found on project home page, http://www.sangupta.com/projects/pemint.
Source Code: https://github.com/sangupta/pepmint
Downloads: https://github.com/sangupta/pepmint/downloads
Issue Management: https://github.com/sangupta/pepmint/issues
Usage Instructions: https://github.com/sangupta/pepmint/blob/master/README.md

Have Fun Highlighting!

Rate-Limited Java Client Dribbble API

2012-04-18T14:35:00.000+05:30

I am happy to finish and open-source a strongly-typed, rate-limited Java Client library for Dribbble called dribbble-java-client.

dribbble-java-client is a strongly typed Java library for accessing http://dribbble.com API. The library provides support for rate limiting requests. All objects implement the necessary equals, hashcode and toString methods for easier usage. Also, implemented is the Comparable interface for comparison and sorting.

The library also exposes a convenience class called DribbbleInvoker that may be used to add more APIs (should they get added in future and this library looses track). The invoker is rate-limit safe.

Usage

DribbbleClient client = new DribbbleClient();

// get info on shot with ID: 1
Shot shot = client.getShot(1);

// get info on this shot's player
Player player = client.getPlayer(shot.getPlayer().getId());

// do more...

Pagination Support

All API methods that support pagination have a corresponding, pagination-aware method available as well. For example, when fetching comments for a shot you may do,

DribbbleClient client = new DribbbleClient();

CommentList list = getShotComments(1);

// do something with these comments

if(list.getPage() < list.getPages()) {
    list = getShotComments(1, 2); // to get default page 2

    // or, may provide the number of results to fetch as well
    list = getShotComments(1, 2, 15);
}

// get more comments

The current default for number of results per page is 15 per Dribbble API. Refer http://dribbble.com/api for more details.

Project Links

More details on the project can be found on project home page, http://www.sangupta.com/projects/dribbble-java-client.
Source Code: https://github.com/sangupta/dribbble-java-client
Downloads: https://github.com/sangupta/dribbble-java-client/downloads
Issue Management: https://github.com/sangupta/dribbble-java-client/issues
Usage Instructions: https://github.com/sangupta/dribbble-java-client/blob/master/README.md

Hope this helps.

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.