Steve Daskam's Blog

TDD Best Practices

stevedaskam — Sat, 16 Jul 2011 19:08:46 +0000

Here’s a list of TDD best practices that I have been accumulating in my developer toolbox. Ping me if you think I’m missing anything, and I will add it to the list.

Have separate source and test folders. Test code should follow the structure of source.
Test should fail the first time it’s written/run
Test names should reflect intent, and names should be expressive
Refactor to remove duplicate code after passing test
Re-run tests after every refactoring
Only write new code when a test is failing. Each test should test new/different behavior.
Write the assertion first
Minimize the assertions in each test
All tests should pass before writing the next test
Only refactor when all tests are passing
Write the simplest code to pass the test
Don’t introduce dependencies between tests. Test should pass when run in any order.
Tests should run fast. A slow test is a test that won’t get run.
Use mock objects to test code at system boundaries (e.g. database, container, file system) so that tests run fast.

Using JPA to Insert and Retrieve BLOBs and CLOBs

stevedaskam — Tue, 29 Mar 2011 02:57:19 +0000

I spent some time recently exploring how to insert and retrieve BLOBs and CLOBs in Oracle using JPA/Hibernate. Here’s an example of how to do it:

The table:
CREATE table large_table_demo ( table_id Integer,


     clob_column CLOB,
     blob_column BLOB

);

The JPA annotated class:

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Lob;
import javax.persistence.Table;

@Entity
@Table(name="LARGE_TABLE_DEMO")
public class LargeTable {
	private Long tableId;
	private String clob;
	private MyObject blob;
	
	@Id
	@Column(name="TABLE_ID")
	public Long getTableId() {
		return tableId;
	}
	
	public void setTableId(Long tableId) {
		this.tableId = tableId;
	}
	
	@Lob
	@Column(name="CLOB_COLUMN")
	public String getClob() {
		return clob;
	}
	
	public void setClob(String clob) {
		this.clob = clob;
	}

	@Lob
	@Column(name="BLOB_COLUMN")
	public MyObject getBlob() {
		return blob;
	}

	public void setBlob(MyObject blob) {
		this.blob = blob;
	}
	
}

The Test Class:

public class BlobTest extends BaseDaoTests {

    @Autowired
    protected BlobDao blobDao;
	
    public void testJpaBlobSave() throws Exception {
        // Read in serialized object
        FileInputStream f_in = new FileInputStream("c:\\myobject.data");
        ObjectInputStream obj_in = new ObjectInputStream (f_in);
        Object obj = obj_in.readObject();
        MyObject myObject = (MyObject)obj;
	    	
        LargeTable lt = new LargeTable();
        lt.setTableId(1L);
        lt.setBlob(myObject);
	    	
        // Save file to DB
        blobDao.saveObject(lt);    	
    }
    
    public void testJpaBlobRetrieve() throws Exception {
    	Object obj = blobDao.find(LargeTable.class, 1L);
    	LargeTable lt = (LargeTable)obj;
        assertEquals(Long.valueOf(1L), lt.getTableId());
    }

    public void testClobSave() throws Exception {
       // Read in text file
       String s = readFileAsString("c:\\clobtest.txt");
       LargeTable lt = new LargeTable();
       lt.setTableId(2L);
       lt.setClob(s);
    		
       blobDao.saveObject(lt);
    }

    public void testClobRetrieve() throws Exception {
        Object obj = blobDao.find(LargeTable.class, 2L);
        LargeTable lt = (LargeTable)obj;
        assertEquals(Long.valueOf(2L), lt.getTableId());
    }
	
    private String readFileAsString(String filePath) throws java.io.IOException {
        StringBuffer fileData = new StringBuffer();
        BufferedReader reader = new BufferedReader(
                new FileReader(filePath));
        char[] buf = new char[1024];
        int numRead=0;
        while((numRead=reader.read(buf)) != -1){
            String readData = String.valueOf(buf, 0, numRead);
            fileData.append(readData);
            buf = new char[1024];
        }
        reader.close();
        return fileData.toString();
    }
}

Copy from Excel into HTML Table

stevedaskam — Mon, 28 Mar 2011 00:47:27 +0000

Using the code below, you can paste a column of cells from an Excel spreadsheet into a column of an HTML table. Just open up a spreadsheet, select multiple cells in a single column, and hit CTRL-C. Then open up this code in your web browser, and click the Paste button.

NOTE that this code only works with the IE browser.


Test Copy/Paste

Steps for Success as a Technical Lead

stevedaskam — Sat, 16 Oct 2010 13:59:28 +0000

There are many challenges to being successful as a technical lead. Each project is unique, having it’s own set of technical nuances and difficulties. And each project team is different, with many individuals, all having their own strengths, weaknesses, and interests that have to be taken into account.

As a lead, you are responsible for the outcome of a project without being given much formal authority. And many times you have to deal with the unpleasantries of company bureaucracy and politics, as well as the fact that your personal coding time takes a back seat to the larger matters of keeping everyone else on track.

But that being said, there are certain principles that you can follow to help set yourself up for success. Many of these principles are detailed in this article: 36 steps to Success as a Technical Lead.

The Binary Search Challenge

stevedaskam — Fri, 01 Oct 2010 20:16:37 +0000

I came across this post recently that claimed that only 10% of professional programmers can write a correct implementation of a binary search. The post quotes the book “Programming Pearls” by Jon Bentley, and says that there’s a passage which claims that the assignment of writing a proper binary search routine was given to over a hundred programmers at companies like Bell Labs and IBM. These developers were given several hours to come up with a solution and afterwords were allowed to test their code. Only 10% had gotten it right.

Now this is not surprising to me as Knuth points out that while the first binary search was published in 1946, the first published binary search without bugs did not appear until 1962. And come on, how often do programmers get anything right the first time? That’s why they invented TDD and refactoring.

So, since I have never actually written this algorithm myself, I thought it would be fun to take the challenge. Using only the requirements below, write a correctly functioning implementation of the binary search algorithm in the language or your choice.

Binary search solves the problem [of searching within a pre-sorted array] by keeping track of a range within the array in which T [i.e. the sought value] must be if it is anywhere in the array. Initially, the range is the entire array. The range is shrunk by comparing its middle element to T and discarding half the range. The process continues until T is discovered in the array, or until the range in which it must lie is known to be empty. In an N-element table, the search uses roughly log(2) N comparisons.

I spent around 1 1/2 to 2 hours max to come up with my initial implementation in java below…pardon my unclean rough draft. Unfortunately, I didn’t get it right the first time, but was able to easily write the code and tests for it within the above timeframe. The algorithm has some small subtleties that are tricky.

I have tested it with the following data and it works fine. Note that the algorithm requires the array to be pre-sorted.
Test 1: private Integer[] myArray = {1};
Test 2: private Integer[] myArray = {1, 5};
Test 3: private Integer[] myArray = {1, 3, 5};
Test 4: private Integer[] myArray = {1, 3, 5, 8, 9, 10, 12, 15};

My Binary Search Implementation

public int binarySearch(int t) {		
   return search(t, 0, myArray.length - 1);
}

private int search(int t, int start, int end) {
   // Not enough items to divide in half
   if (end - start < 2) {
      for (int i = start; i <= end; i++) {
         if (t == myArray[i]) {
            return i;
         }
      }
      return -1;
   }
		
   int pos = ((end - start) / 2) + start;
   if (t == myArray[pos]) {
      return pos;
   } else if (t > myArray[pos]) {
      return search(t, pos + 1, end);
   } else {
      return search(t, start, pos - 1);
   }
}

I originally vascillated between using a loop and using recursion, but I ended up choosing recursion as it seemed a little easier to get my head around. Also, I chose to return -1 if the search value was not found (opposed to the java way of returning -(insertion point + 1)) as there was no specifics about this in the requirements.

After I had finished the code, I came across this post by Josh Bloch that talks about his implementation (which is much cleaner, see below). Bloch talks about how a bug had been reported on his implementation of the binary search algorithm in java, and I was happy to find that I had been able to avoid the bug in my own code above without even knowing that the problem had existed in java

Java Binary Search Algorithm – written by Josh Bloch

1:     public static int binarySearch(int[] a, int key) {
2:         int low = 0;
3:         int high = a.length - 1;
4:
5:         while (low <= high) {
6:             int mid = low + ((high - low) / 2);
7:             int midVal = a[mid];
8:
9:             if (midVal < key)
10:                 low = mid + 1
11:             else if (midVal > key)
12:                 high = mid - 1;
13:             else
14:                 return mid; // key found
15:         }
16:         return -(low + 1);  // key not found.
17:     }

Fast & Easy Screen Mockups with Balsamiq

stevedaskam — Sat, 07 Aug 2010 02:50:20 +0000

There’s a great tool for creating quick and easy screen mockups called Balsamiq. The wireframes created using the tool are intentionally left rough looking (like they were just thrown together) so that users won’t think they’re actual working screens. This is very helpful for getting fast feedback on your screen layouts.

You can find Balsamiq at the link below. The cost is a low $79.

http://www.balsamiq.com/

Cloud Storage with Amazon’s SimpleDB

stevedaskam — Fri, 30 Jul 2010 03:42:40 +0000

Part of the Amazon Web Services family, Amazon’s SimpleDB is a massively scalable and reliable key/value datastore that is exposed via a web interface and can be accessed using the Java language.

Get started with Amazon’s SimpleDB in this two part series exploring SimpleDB’s unique approach to schemaless data storage, including a demonstration of one of the datastore’s most unusual features: lexicographic searching.

Part 1:
http://www.ibm.com/developerworks/java/library/j-javadev2-9/

Part 2:
http://www.ibm.com/developerworks/java/library/j-javadev2-10.html

Amazon Dynamo

stevedaskam — Fri, 30 Jul 2010 03:05:13 +0000

Here’s a nice white paper from Werner Vogels, CTO of Amazon, describing Dynamo, Amazon’s Highly Available Key-Value Store:

http://s3.amazonaws.com/AllThingsDistributed/sosp/amazon-dynamo-sosp2007.pdf

JavaZone Movie Trailer

stevedaskam — Tue, 20 Jul 2010 03:37:53 +0000

You have to check out this movie trailer at JavaZone. It’s hysterical!!

http://jz10.java.no/java-4-ever-trailer.html

FaceBook Architecture

stevedaskam — Thu, 01 Jul 2010 03:27:07 +0000

There’s a couple of interesting presentations on InfoQ about the architecture at FaceBook:

http://www.infoq.com/presentations/Facebook-Moving-Fast-at-Scale

http://www.infoq.com/presentations/Scale-at-Facebook

It sounds like the culture at the company is very developer-friendly, and the graphic below is pretty amazing.

The FaceBook architecture includes these technologies:
Linux, PHP, MySQL, Memcached, Thrift (for web services), Cassandra

Some interesting points from the presentations:

Memcached can handle about 250,000 requests per second, and scaled out at FaceBook it handles about 50 million requests per second
FaceBook has tens of terabytes of RAM in use with thousands of servers