Meetings do provide a value but sometimes they do not justify the cost of interruption and loss of productivity. Some of the problems with traditional meetings is that it creates a culture of compromise and they kill our sense of urgency. People would avoid making a decision and leave it for the people attending the meeting, or people would avoid taking up a responsibility and leave it to the people attending the meeting.

More often people call for meetings with out any preparation or proper agenda. They would often invite people with out understanding the value they would bring to the table. Also not having a proper agenda will bring attendees unprepared.

In the book “Read This Before Our Next Meeting” author Al Pittampalli lays out some ground rules for modern meetings. Following are the ground rules for a meeting

1) Modern meetings supports a decision that has already been taken.
A decision should not be left for a meeting. A tentative decision should have already been made by consulting people if required. A meeting should be held to ratify the decision or to make amendments to the decision. This will result in having a meeting with clear purpose and clear outcome.

2) Modern meetings moves fast and ends on schedule.
As the rule says meetings should be kept on track and on the purpose.

3) Modern meetings limits the number of attendees.
This is very important. Invite people who are absolutely necessary. If required one can convey the outcome of a meeting for rest of the people in a formal email. If more people are invoked it creates uncertainty in the decision.

4) Modern meetings rejects the unprepared.
As the rule says no attendee can come to meeting with out understanding his / her role in the meeting. Everyone should come prepared to the meeting. For ex. modern meeting is not a place to bring people up to speed.

5) Modern meetings produces committed action plan.
Every meeting should have a outcome and committed action plan.

6) Modern meetings refuses to be informal. reading memos is important.
This means people should take meetings quite seriously. They should read all the memos / documents that are sent regarding the meeting. Meetings should be very formal and should not be a place for personal conversation.

7) Modern meetings works only alongside a culture of brainstorming.
New ideas should come out of the meetings.

For detailed explanation I would recommend reading this book. As a promotion Kindle version is available free for limited time.

Read This Before Our Next Meeting [Kindle Edition]

Of course with every new release comes new features, better performance, new syntax etc. Some of the noteworthy features

1) One of the biggest feature is invokeDynamic. This makes interactions between Java and other dynamic languages like JRuby, Jython, Groovy and other 200 languages that are on JVM seamless. Now JVM can optimize the bytecode produced by these languages. We can choose to write code in any language that best solves the problem and compile it against JVM to get all the JVM capabilities like optimization, garbage collection etc

2) Second big feature is language enhancements. Biggest complaint about java is that its verbose / or has lot of ceremony in writing code. With project “coin” in Java7 we will see some language enhancements. For ex

Improved type inference for generic instance creation

//In Java 6
Map<String, List<String>> mapoflists = new HashMap<String, List<String>>();

//In Java 7
Map<String, List<String>> mapoflists = new HashMap<>();

Similarly Multi Catch blocks

try {
//Do Something;
catch(Exp1 | Exp2 |Exp3) {
//Do something
}

3) We are in an age where servers with multiple cores are very common. Having language features that enables us to use all these processing power is very helpful. Java7 has enhancements for Concurrent and Collections API that enable us to write applications to use multiple processors.

4) Enhanced NIO

For more features and information follow these links

Oracle Java 7 page

Javalobby Introducing Java 7

Learn how to develop for Android, Beyond HelloWorld

Want to learn some best practices. Title of the video is wrong, its actually not a ‘Beginners guide to Android’. Presenter changes the talk after 5 minutes into it.

Android best practices for beginners

http://deve.loping.net/projects/ignoflash/

It’s was very easy to apply the patch and now I can play my videos in full screen while working. Thank you very much Mr. Alex Gembe.

A man left his three children with 17 camels. According to the will first son gets half of the camels, second son gets third of the camels and the youngest gets ninth of the camels. Three sons got into negotiations, realizing they cannot split without killing the camels they started to argue and finally in desperation they consulted a wise old women.

Wise old women thought about their problem for long time and finally she came back and said, I don’t know if I can help, but at least if you want you can have my camel.

So now they had 18 camels….

First son took his half, half of 18 is 9; Second son took his third, third of 18 is 6; finally youngest took his ninth, ninth of 18 is 2 and yet the total was only 17 and there was one camel left over which they gave it back to old wise women.

The moral of the story is every problem or conflict can be resolved with a fresh look. Every conflict has two sides but it’s the third side ‘us’ who should participate in resolving the conflict.

Google provides API to manage any documents on Google docs and different API to manage spreadsheets. API’s are in the form of restful services where in client application’s can manage documents by making HTTP requests to Google.

Google Documents List API: This API provides functionalities for managing documents. This includes searching, retrieving, uploading, updating, copying, downloading and deleting of documents, creating and moving folders, modifying folder and document permissions, managing document revisions and finally some special features like document translation and Optical character recognition.

Google Spreadsheet API: This API is specifically for managing data inside a spreadsheet. Clients can use this API to manage worksheets, tables, records and cells inside a spreadsheet. This API does not provide functionality to create and delete a spreadsheet, but this can be easily done by using documents list API.

To interact with these API’s one has to have a Google account and client needs to pass in an authorization key with every request. Before a client can start using the API it has to authenticate the user by passing in username and password along with the service name for which it needs authorization key for. An authorization key obtained for one service cannot be used for other service. Click for complete list of API’s and their respective service names.

Google provides couple of different ways to authenticate a client application. One is by using ClientLogin specifically for single user client applications and other is by using AuthSub proxy authentication for multi user web applications. Either way the idea is to acquire an authorization key or token that has to be passed for every client interaction with the API.

Every request a client makes to Google docs, it has to specify the GData-Version in the headers of the request. Current version is 3.0. Every document created or uploaded to Google docs is given a unique document ID. Clients has to use this ID to perform any further actions on the document.

Problem 1:

Create an empty spread sheet in Google docs by name ‘Example.xls’ and return the document ID. Before, check to see if the spreadsheet is already present in Google docs, if present return its document ID without creating new one again.

• 1) Authenticate with Documents List API and get a Auth key
• 2) Search for the spreadsheet by name ‘Example.xls’, If spreadsheet exists retrieve the ID
• 3) If spreadsheet is not found create the a blank spreadsheet by name ‘Example.xls’

Document’s List API is a service of type ‘writely’. A HTTP post request is made to ClentLogin URL to get the auth key.

//URL for ClientLogin
var url = 'https://www.google.com/accounts/ClientLogin';

//Content type has to be this
var ct = 'application/x-www-form-urlencoded';

// account type is HOSTED or GOOGLE when unsure use following
var at = 'HOSTED_OR_GOOGLE';

var un = 'your Google email';
var pwd = 'your password';

var serv = 'writely'

//This can be any fixed string. Used for logging by Google
var src = 'application identifier’

var request = new Ajax.Request(url, {
  method: 'post',
  contentType: ct,
  parameters: {accountType: at, Email: un, Passwd: pwd, service: serv, source: src},
  
  onSuccess: function(response){
    // Parse the auth key from response and save it somewhere
    //do something else like call search method to find the spreadsheet
  }.bind(this),
     onFailure: function(response){
     // puke, look for status and act accordingly
  }.bind(this)
});

To determine authorization key one has to parse the response. The response is returned as Key = Value pairs and client needs to look for ‘Auth’ key. If for any reason Google fails to authenticate the user it returns a response along with error code.

var a = null;
var pairs = response.responseText.split("\n");
	 
for (var i=0; i <pairs.length; i++){
  var fields = pairs[i].split("=");
  var key = fields[0];
  if(fields[0] == 'Auth') {
    a = fields[1]
    break;
  }
}

Searching for documents is very straight forward. One can perform queries on document types, names , locations and meta-data. For our example I am looking for a spreadsheet with name ‘Example.xls’ in my private folders.

var spreadsheetName = 'Example.xls';

// authWritely is the key obtained as part of ClientLogin
var auth = 'GoogleLogin auth='+this.authWritely;

var url = "https://docs.google.com/feeds/default/private/full/-/spreadsheet?title="+spreadsheetName+"&title-exact=true&showdeleted=false";

//Content type
var ct = 'application/atom+xml';

var request = new Ajax.Request(url,{
   method: 'get',
   evalJSON: 'false',
   contentType:ct,
   requestHeaders:{ Authorization: auth , 'GData-Version':'3.0'},
   onSuccess: function(response){
     //Search for document Id
     //If no spreadsheet is returned create one 	
   }.bind(this),
   onFailure: function(response){
     // puke, look for status and act accordingly
   }.bind(this)
 });

If a document is found with the search criteria a list of document entries are returned along with document ID and URL’s to manipulate the document. The easiest way to determine the document ID is to search for ‘resourceId’ in the response XML.

var id = null;
var resp = response.responseXML;
var entries = resp.getElementsByTagName('entry');
	
for(var i=0; i<entries.length; i++) {
  var resourceId = entries[i].getElementsByTagName('resourceId')[0].firstChild.nodeValue;
  var resourceIdSplit = resourceId.split(':');
  if (resourceIdSplit[0] == 'spreadsheet') {
    id = resourceIdSplit[1];
    break;
  } 			 				
}

To create a new document one has to post an entry request to Google docs. Following code snippet creates a new spreadsheet with name ‘Example.xls’ in private/full location. Using same approach clients can create any type of document under any location.

var spreadsheetName = 'Example.xls';

//Content type
var ct = 'application/atom+xml';

var pbody = '<?xml version="1.0" encoding="UTF-8"?>\
		    <entry xmlns="http://www.w3.org/2005/Atom">\
		    <category scheme="http://schemas.google.com/g/2005#kind"\
		          term="http://schemas.google.com/docs/2007#spreadsheet"/>\
		      <title>'+this.spreadsheetName+'</title>\
		    </entry>';
	
var auth = 'GoogleLogin auth='+this.authWritely;

var url = "https://docs.google.com/feeds/default/private/full";

var request = new Ajax.Request(url, {
  method: 'post',
  contentType:ct,
  evalJSON: 'false',
  contentLength: pbody.length,
  postBody: pbody,
  requestHeaders:{ Authorization: auth , 'GData-Version':'3.0'},
  onSuccess: function(response){
    // Document is created
    // Get the document id 
  }.bind(this),
  onFailure: function(response){
    // puke, look for status and act accordingly
  }.bind(this)
}); 

This completes the problem to authenticate a user, search for a spreadsheet and create a new spread sheet.

CHANNELS
——————————–
| ID | NAME | TYPE |
——————————–

TYPE field is a varchar that can take only SD, HD and 3D.

PROBLEM:

To get a list of channels sorted by TYPE in an order of SD, HD and 3D. This can be done in couple of different ways:

-- Using by FIELD
SELECT * FROM CHANNELS ORDER BY FIELD(TYPE, 'SD', 'HD', '3D'); 

-- Using by FIND_IN_SET
SELECT * FROM CHANNELS ORDER BY FIND_IN_SET(TYPE, 'SD,HD,3D');

If you know any other way please leave a comment

CUSTOMER
—————————————————————————–
| ID | FirstName | LastName | LicenceExpiryDate |
—————————————————————————–

We are testing a method called isLicenceExpired(id). To unit test this method we can setup some dummy data using DbUnits.

<?xml version='1.0' encoding='UTF-8'?>
<dataset>
  <CUSTOMER ID="1" FIRSTNAME="FirstName1" LASTNAME="LastName1" LICENCEEXPIRTDATE="2010-08-25" 
  <CUSTOMER ID="2" FIRSTNAME="FirstName2" LASTNAME="LastName2" LICENCEEXPIRTDATE="2010-09-15" 
  <CUSTOMER ID="3" FIRSTNAME="FirstName3" LASTNAME="LastName3" LICENCEEXPIRTDATE="2011-01-01" 
</dataset>

Problem with above setup is test-cases would eventually fail because of ‘LicenceExpiryDate’. We need to setup this date such that it’s relative to current date. This is where ReplacementDataSet comes into picture. This class decorates FlatXmlDataSet class to provide replacement functionality. Now we can define your data set as

<?xml version='1.0' encoding='UTF-8'?>
<dataset>
  <CUSTOMER ID="1" FIRSTNAME="FirstName1" LASTNAME="LastName1" LICENCEEXPIRTDATE="${today+10}" 
  <CUSTOMER ID="2" FIRSTNAME="FirstName2" LASTNAME="LastName2" LICENCEEXPIRTDATE="${today+30}" 
  <CUSTOMER ID="3" FIRSTNAME="FirstName3" LASTNAME="LastName3" LICENCEEXPIRTDATE="${today+100}" 
</dataset>

and example setupDataWithReplacement method would look like

public static void setupDataWithReplacement(String fileName, Map<String,Object> replacements) throws Exception {
  
  //Get database connection.
  Connection conn = ds.getConnection();
  //When there are multiple databases 
  conn.setCatalog(DATABASE_NAME);
  try {
    IDatabaseConnection connection = new DatabaseConnection(conn,DATABASE_NAME);
    connection.getConfig().setProperty(DatabaseConfig.FEATURE_QUALIFIED_TABLE_NAMES, true);

    IDataSet dataSet = new FlatXmlDataSet(AbstractTransactionalDasDataTests.class.getClassLoader().getResourceAsStream(fileName));

    //Decorate the class and call addReplacementObject method
    ReplacementDataSet rDataSet = new ReplacementDataSet(dataSet);
    for (String key : replacements.keySet()) {
      rDataSet.addReplacementObject("${"+key+"}", replacements.get(key));
    }

    DatabaseOperation.INSERT.execute(connection, rDataSet);
			
  } catch (Exception e) {
    e.printStackTrace();
  } finally {
    DataSourceUtils.releaseConnection(conn, ds);
  }
}

Now we can setup data like before we run our tests

Date today = new Date();
Map<String,Object> replacements = new HashMap<String,Object>();
replacements.put("today+10", DateUtils.addDays(today, 10));
replacements.put("today+30", DateUtils.addDays(today, 30));
replacements.put("today+100", DateUtils.addDays(today, 100));
setupDataWithReplacement("customer-test-data.xml",replacements);

Language is just a tool: Many times people forget that programming language is just a tool to solve problems. In the end it boils down to problem and a right solution. A problem can be solved in any language, but certain problem’s can be best solved by using certain languages while others are best suited for other problems. It depends upon using right programming language for solving a particular problem.

Be a polyglot programmer: Languages are evolving continuously. Each new language that is created tries to solve some complexities with old languages. Even advancement in chip and memory technologies is driving creation of new programming languages. Once many of the popular languages are compiled, now many modern languages are interpreted. Languages are becoming more abstract. If we look at modern languages, we are writing less code either via plugging in code or configuring (via xml or annotations) code or by auto-generating code. Being a polyglot programmer does not mean gaining expertise in many different languages but more of understanding capabilities of different programming languages and using them appropriately.

Understand your problem and time-lines: A problem can be solved in an optimal way or bad way or all the ways in between. Balancing a solution and time-line is the key. One can take a month to come up with best solution or a day to come up with a crappy one, but coming up with working solution, that solves the current needs in the given time line is important. It’s all in knowing what language to pick to solve a particular problem.

Don’t be scared: Core programming concepts are the same in all programming languages. Some languages might support these concepts well while others don’t. Playing with many different languages and understanding its capabilities makes a good software developer.

A fun video for those who do not agree with me…