Wattdepot Katas

Recently in the software engineering class, we had introduced to a custom built software called WattDepot.  This software 

was designed and built for a project to allow the university to monitor power and energy consumption of the school 

dormitories.  As a way to familiarize ourselves with this custom built software, we were instructed this week to develop a few 

short programs to perform basic data retrieval functions from the wattdepot server.    

Initially, the amount of information was a bit overwhelming, and took awhile to decipher how to user certain components 

correctly.  Some of the technical information provided by the javadocs were a bit sparse at times, and at times were not very 

helpful.  However, with that being said, when one spends enough time perusing through every possible document and 

fiddling around with the functions, it became familiar and easier once I got the hand of it.

In total, I probably spent around 8 to 10 hours working on these programs.  There was about a good hour or so just to 

read through the documentation and articles to get a good grasp on what this project was, and how to implement the code 

that would communicate with the wattdepot server.  I had to figure out a system of how to test my programs from the command 

line so that they would talk to the actual wattdepot server, and found an easy way to do this with a simple change to the 

jar.build.xml file that came with the wattdepot download.    

SourceListing:

The first “kata” called sourcelisting was quite simple and took about 5 minutes to write and test.  Using the simple application program that came with the source files as a basis for the program, it was a matter of changing a few things around.

SourceHierarchy:

This kata was a bit of a hassle due to some of the confusion induced by the methods of the classes.  At this point, I was 

still figuring out exactly how to use the methods correctly and so was unsure what to call for the class objects that I had 

created.  At first I had used the owner from the source class thinking that it would indicate some kind of network of the source 

hierarchy, but found that that was not correct when I printed out the results.  I am not certain that I used the correct methods to 

determine the source hierarchy, however I did receive results that looked promising with the isSetOwner method, which 

shows some form of ordering through inspection of the source name.  In the end, I probably spent about an hour to an hour 

and a half on this implementation.

SourceLatency:

This kata was pretty simple to do because it was a bit of a rehash of the simple application code.  However, I spent a 

good chunk of time wondering how to calculate the latency.  I actually skipped this problem and went on to the others, and 

came back and did this after.  After looking at the simple app code, it was quite easy to devise some code of how to do 

calculate the latency.  Including the amount of time I spent pondering how to do the problem, it took me about an hour or so to 

complete.

EnergyYesterday:

This kata was the one I probably spent the most time on.  It was the first problem that involved the energy retrieval and 

multiple timestamps.  After tinkering with the methods for awhile, and testing to see that I was actually implementing them 

correctly, the issue of how to sort and display the corresponding source name took some time to solve.  This was particularly 

time consuming because in the software package there is no inherent method for sorting or mapping.  So I actually 

implemented a hash map, which is probably not the most efficient process due to some lag time when the program executes, 

but it seemed to do the trick.  With all the hurdles and lessons learned from building this program I spent about 2 1/2 hours. 

MondayAverageEnergy:

After doing the EnergyYesterday program, this was a breeze because I had done all the work already for the previous 

program.  This was a simple matter of changing around the timestamps and averaging the values of the collection points.  

There were a few issues while debugging the program, but found most of the problems were syntax errors.  This took about 

hour to complete.

HighestRecordedPowerYesterday:

Unfortunately, I did not get this program to work correctly.  I did get some results from the power retrieval method, 

however, they don’t seem to make any sense.  I think the problem may be the time interval that it is collecting at. I assumed 

that the timestamp increment method was the only way to continuously change the hour, however when printing the results of 

the collection times, the data didn’t seem to change.  I actually worked on this program, but then moved on and came back to 

it later.  I spent a total of 2 hours on this problem.

    In conclusion, this was a very time consuming task, due to the fact that we were learning how to implement custom made 

software, and the extensive amount of parameters and collection processes.  All in all, it was a good learning experience and 

gives a sense of what it takes to develop software for a system.  There is obviously a whole lot more functionality built into the 

software, and for this assignment, it seems as though we’ve barely scraped the surface of manipulating the data.