In this post, I will talk about FizzBuzz and the concept of asking questions that graduate developers should know. According to the coding horror article 199/200 programmers can not program out of college. This statistic seems high and has since been revisited to explain how he came up with the figures. What I find interesting is from my experience, in my undergraduate and masters courses – was that a high percentage of graduates would not be able to do the fizzbuzz problem. This is why graduate screening – problem solving is essential. Microsoft and Google are notorious for asking their candidates to solve problems never seen before by them.

Another observation I had was, the best programmers did not over analyze their solutions. I believe a lot of people can write code, but it is very difficult to master. A great developer is worth a lot to any company. I must admit I have been guilty of over analyzing my solutions. As I strive to become a good developer I learn quicker, better ways to do things.

Without a further ado my fizzbuzz solution!

/**

* The Problem:
* Write a program that prints out the numbers 1 to 100.
* But for multiples of three print “Fizz”, instead of the number
* and for multiples of five print “Buzz”.
* For numbers which are multiples of both three and five print “FizzBuzz”
*
* Expected output:
* 1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz
* 16 17 Fizz 19 Buzz Fizz 22 23 Fizz Buzz 26 Fizz 28 29 FizzBuzz
* 31 32 Fizz 34 Buzz Fizz 37 38 Fizz Buzz 41 Fizz 43 44 FizzBuzz
* 46 47 Fizz 49 Buzz Fizz 52 53 Fizz Buzz 56 Fizz 58 59 FizzBuzz
* 61 62 Fizz 64 Buzz Fizz 67 68 Fizz Buzz 71 Fizz 73 74 FizzBuzz
* 76 77 Fizz 79 Buzz Fizz 82 83 Fizz Buzz 86 Fizz 88 89 FizzBuzz
* 91 92 Fizz 94 Buzz Fizz 97 98 Fizz Buzz
*/

public static void fizzBuzz() {
for(int i = 1; i < 101; i++) {
if (i % 3== 0 || i % 5 == 0) {
if (i % 3 == 0)
System.out.print("Fizz");
if (i % 5 == 0)
System.out.print("Buzz");
} else
System.out.print(i);
System.out.print(" ");
}
}

Guess that means I can program

Microsoft and other companies often request you to complete some algorithms in their interviewing process. Today I completed an attempt at an ArrayBasedStack to be able to find a palindrome. Something I must admit I have not touched since early college! This is going to be the first of some interview questions I got. Plus it is about time I wrote another blog post.

Using the excellent: Data Structures and Algorithms in Java by G&T to define my stack I created an array based stack similar to what they have posted. Each developer has their own style. I prefer using return size() == 0 rather than their (top < 0), but that is my preference.

Just remember a few things

A palindrome is a word, phrase, number or other sequence of units that can be read the same way in either direction (the adjustment of punctuation and spaces between words is generally permitted) – from wiki

Trim whitespace and lowercase the characters.

Stacks work on last in, first out principle. What? Well this comes in handy for the algorithm. LIFO gives you a reverse effect.

So – here it is, the algorithm. Hope it will help you with your stack based palindromes.

private boolean isPalindrome(String str) {

 Stack<Character> stack = new ArrayBasedStack<Character>(str.length());
 str = str.toLowerCase().trim(); //format the data
 while(stack.size()<(str.length()/2)) {
  //When the stack is less than half the length
  //(even numbers great, odd numbers ignore the middle!
stack.push(str.charAt(stack.size()));
//push the character at the position indexed by the size of the stack

 }

 while(stack.size()>0) { //lets go back

if(stack.top() == str.charAt(str.length() - stack.size())) {
//again use the stack size
//to index the position, minus the length
//so this counts down every time something is popped from the stack.
//You are checking the top of the stack is equal to the character
//in 2nd half of the word. since characters go in first, the characters,
//abba would have b on top and a on the bottom when hitting this loop -
//the first two characters - they are the same as the last two. Get it now? 
stack.pop(); //remove palindromic characters

} else {

return false; //it is not a palindrome -
//you don't want to keep going and be inefficient if it is wasting time!

}

 }

 return true; // if it gets here there can only be on conclusion.

}

Hope this helps and you learn my thinking behind this. Good luck with the interviews.

Energboss was my college project for the MBS BIS course for 2009 in University College Cork. Here is a picture of the team on the open day with our mentor Sean Murphy:

Our logo:

Product Description

Energyboss is a home energy-saving product for the times we live in. Position the tiny sensor devices in your key living areas, and connect sensors to your electricity and gas supplies. The process is quick, anyone can do it, and its suitable for old and new homes. Energyboss uses cutting edge technology to display a history of your energy use and room light, heat and humidity using easy to read graphs. To see home performance, save money, and live a greener life, EnergyBoss is the solution.

The Hardware

It consisted of taking real time sensor data from wireless sensors, that formed a wireless sensor network. We used telosb motes which looked like this:

How it worked

Essentially how it worked was one wireless sensor (called a mote) plugged to your PC (base) and one in the room (gathering sensor information and broadcasting the data to the base). The live information would be taken in to an application and stored in a database. A number of calculations can be deduced from the sensor readings. There is a correlation between cost and temperature etc. Other factors like sudden loss of temperature can insinuate problems with insulation or windows etc. The average rating for your house can be calculated with Gas and Electricity readings, which is directly compared to your energy performance (or benchmarked against similar houses in your area). This is a far better rating system than the BER rating offered in Ireland currently as it is real-time, more accurate and helps the individual improve reduce their energy expenses. Even then, energy expenses can often be estimated in Ireland and households can get hit with massive, unexpected charges by utility companies. This product uses ZigBee which could tap into some smart meters in the future, providing accurate information to the bill payer.

The Initial Concept

What I was striving for was something similar to this.

I came up with some mock screen shots, with mock data in them.
Tab1:

Tab1: consisted on a house floor plan. This broke down room by room (image map from flexlib) where a sensor could be placed, and a report could be viewed next to it. Sample reports/graphs included the default interactive flex pie chart and some mini degrafa bar renderers to give a flavor of what could be done. I wanted to go forward with the houseplan, maybe something along the lines of floorplanner or eventually what adobe did, monitoring their HQ in 3d. Somewhat overkill for a simple masters project but where things are heading.

Tab2:

Tab 2: basically outlined some simple historical reports using flex charting. This would need to plug into a database in the long run, SQLite was the choice as it is “a self-contained, serverless, zero-configuration, transactional SQL database engine.” Ideal if the application needed to/could be ported Adobe Air.

The Software

The motes had TinyOS installed on them (Embedded C) in the -1.x flavor.

Crossbow Technology provided the mote and an install CD with a driver that changes the USB to serial port communication. I needed to run the net.tinyos.sf.SerialForwarder application outlined in lesson 6 to run the oscilloscope application in tinyos, and save me learning huge amounts of Embedded C in a limited time frame. All I needed was basic sensor data like light, temperature and humidity that came through the serial forwarder packet information (packet structure outlined in lesson 6).
What the basic oscilloscope program looks like:

My re-engineered Flex version (with real-time sensor data) – more on this later

The mig class can generate the appropriate Java from your embedded C. Since this was already done it was a case of using the existing Java classes and knowing the particular format of the Oscope Message (outlined in lesson 6 of tinyos doc).

Java

From there I needed to manipulate the raw data. First I identified the appropriate channels, finding the correct data associated with it. It was a case then of plugging particular data into some equations in order to get the correct figure, e.g. temperature = -39.60 + 0.01*SOt, where SOt is a particular sensor reading.

The tinyos based motes spoke to Java and a Tomcat server running BlazeDS, which in turn ended up speaking to my Flex/Air front-end. Or should I say Java listened to the comm port using the java comm api, which in turn ran on BlazeDS. My idea for running it in a Flex/Air front-end proved somewhat troublesome, but more on that later.

BlazeDS data push

Using this link here I set about creating the Energyboss application. Instead of the random number generator I replaced it with a thread that gathered information from the comm port/sensor. The sensor data was calculated then sent across the wire. Then in the format of
e.g. “temp: ” +temperatureValue
I populated an ArrayCollection on the Java side and sent it to Flex.

Handling the Data on the Flex Side

I created a producer/consumer definition (publish/subscribe paradigm) which had a messaging buffer/queue for receiving directly from the server-side (the instructions in the presentation in the last section). This information was partitioned to its appropriate bindable ArrayCollection which was auto-updated through Flex as normal. I was able to split the strings above by looking for the ‘: ‘ character in order to allocate to the appropriate ArrayCollection on the flex side! I had a single ArrayCollection solely taking in data from Java. This allowed me to filter out the data into it’s appropriate ArrayCollection (e.g. temp, humidity or light), giving me more flexibility with a series of individual ArrayCollections. Each had a timestamp also, which was added at the time of the Flex client receiving the information. I know I could have added them all to a single ArrayCollection or had different end-points but I wanted to keep the information separate for a number of reasons.

The Finished Application

The left box uses a degrafa dial, which lost it’s style somewhere (ran out of time to find out the issue). This gave a nice indication of your energy rating that is better than the BER already mentioned. The right box indicates the temperature and weather outside.  This allows you to combat your energy usage and adjust it accordingly. In future this feature can help build a profile of your area and your historical readings, to provide a series of recommendations from your past usage. The bottom (in this screen shot is way too small, but in the final had a larger graph with better scales) graphs indicate real-time sensor data. So you can track how your dwelling is doing and adjust accordingly.

Screen2:

This screen shot highlights a historical chart for your usage for the past 12 months. This allows a user to see their performance for the same period last year, and eventually similar weather conditions could be compared also. This chart drills down to every day of every month, and even every hour of every day! It does take a year to get more accurate readings, but sample data can be placed in here until a big enough data set or sample or your history can be obtained. Entering bills for the last 12 months is also an alternative option.

From feedback we received, we wanted to highlight this product is actually paying for itself! The user gets an estimated costing highlighted to them in this screen.

The remaining component was the floor plan and associated chart in each room. It broke down on a room-by-room basis the sensor data. Using the multichart component to display in the graph the user would prefer.

Finally, the reporting section. This lets the user customize a particular chart and data they want in that report. This section used the Flex charting components but had massive room for improvements! Charting in itself is boring, but I could offer the chance to store and reuse particular charts, even provide a dynamic dashboard where the user could dock these charts!

Issues with the Project

• Even at the time of writing this, Tinyos-1.x is well out of date. For the sake of simplicity, or so I thought, I did not upgrade to 2.x version. This was Crossbow’s fault for providing out of date environment at such a large premium.
• Tomcat with BlazeDS ran on Java 1.5 minimum. Since Crossbow provided me with a 1.4 version of Java I had to reconfigure all the environment etc, which wasted a lot of development time.
• Java comm api has been discontinued for Windows. I found an older version somewhere in Google land.
• Flex or Air do not natively support comm port communication. An issue that does not look like it is going to be addressed anytime soon.

1500 words later I hope you enjoyed my Masters project. It was fun developing it! Feel free to contact me with any quries you have on this. I will not provide the source code, mainly because I do not have access to the senors anymore, but if you wish to know how any of it worked I will try to help!