Here’s an interesting problem…

Given an undirected graph, find all the paths (not just the shortest) between two nodes that are less than some given length.

I decided to attack this problem using Haskell. Simply because I’ve been trying to get to grips with the language and felt that this was a nice “real” problem for me to practice my fledgling skills on. I’ve chosen to model a graph as a list of edges which are described as a simple pair (see the end of the following source code). I have therefore made the following assumptions in the code;

• An entry in the list (‘a’,'b’) explicitly states that an edge exists between the nodes ‘a’ and ‘b’ and further this implies that the edge (‘b’,'a’) exists since the graph is undirected.
• An entry (‘a’,'a’) implies that a node ‘a’ exists that does not have any edges, rather than an edge exists that self-references the node ‘a’. Nodes are not allowed to have edges to themselves.

The following code does work, and returns the correct number of paths given my test data and the requests I make of it. I can’t escape the feeling, though, that my Haskell could be made more simple and efficient. I just don’t know Haskell well enough yet to work out how!

The Solution

Edit 1: code to apply Hlint comments

Edit 2: corrected some cut and paste mistakes


import Data.List

Introduction

I’ve managed to find some time recently to get playing with my SUN SPOTs again, so I figured I’d start by wiring up one of the servos from my ancient remote control cars to it. Although, there seems to be a lot of information about doing this on the web (mostly the wiring diagrams) I hit a snag with getting the full motion range out of my servo. So I figured I’d put something up here in case anyone else encounters the same.

Scenario

To control my servo I wrote a very quick GUI that allowed me to send float values through the connected base station to the free range SUN SPOT. That SPOT was wired up to a battery pack and servo and the servo moved when I hit the GUIs button. Simple, but a nice first step.

The Setup

I mostly copied the wiring of the servos from “Fantastic Kobe” and this offical SUN blog. There’s not a lot to the wiring, as you can see from this picture.

Shows the wiring from the battery pack and SUNSPOT to the Servo

I not going to go into detail about what connects where, because that information can easily be found on either of the above two links.

Setting the Servo Bounds

One of the things I found was using the setPosition(float p) method on Servo wasn’t giving me the full range of motion. To fix this you need to set the bounds of your particular servo. I didn’t know the ‘correct’ way to do this, so instead I went with a trial-and-error approach.

private int servoPin = EDemoBoard.H1;

private void initServo() {
servo = new Servo(EDemoBoard.getInstance().getOutputPins()[servoPin]);
// for(int i=250; i<2300; i+=10) {
// servo.setValue(i);
// out("value="+i);
// Utils.sleep(100);
// }
servo.setBounds(250, 2300);
}

In the above code, the starting value of “i” was originally zero and the end value was 10000. Then, by using changing these values so that when initServo() was called the servo didn’t groan in protect, I was able to set the bounds as shown. Having done that, servo.setValue(0.5); puts the servo in the middle as expected. With values of 0 and 1.0 taking the servo to its extremes.

I expect that most people’s servos are going to be different. Mine is a Futaba FP-S148. And now I can move a servo around, I can start to do something useful (or at least fun) with it!

The Code (Free Range SPOT)

There is only one class in the application that sits on the free range SPOT.
import java.io.IOException;

}

The Code (Base Station)

The code on the base station is simple enough, in fact too simple to warrent posting and spending the time formatting it here. The only interesting bit is the following line which is one of the first lines in the public static void main(String[] args) method;

OTACommandServer.getInstance().start();

The rest of the code is either UI/Swing code or normal Java/SUN SPOT code. In fact, the initComms, sendMessage, startListenerThread and listenForMessage methods are identical to those that run on the free range SPOT. The only difference is the SPOT address that the DatagramConnection is opened with. Obviously, on the free range SPOT it is opened with the address of the base station, and the reverse for the code on the base station.

Aside

Disclaimer: Obviously, soldering is dangerous to yourself and the components you’re working on/with. Any damage or injury you sustain following this advice is entirely at your own risk and I accept no responsibilty for it.

…that being said; if you don’t have a decent breakout board for your SUN SPOTs (and you’re in the UK) then Maplin do some PCB socket connector things* that you can buy and solder into your SUN SPOT. This gives you the ability to use bread board connector cables to easily connect up different sockets from the SUN SPOT without having to do any resoldering. The soldering its self is a bit fiddly, so I recommend getting a decent magnifying glass and a soldering iron with a fine tip. I’m definitely not the worlds best solder-er but I managed it okay.

* – I forget the actual name or catalogue reference, they’re pretty cheap (less than a pound I think) and are sold in rows of about 20 or so. You just snap off two rows of 10 each and get on with it.

Useful Links

• SUN SPOT API Doc

I have recently been lucky enough to borrow a set of very cool Sun SPOTs, so I immediately began thinking of all the amazingly clever and brilliant things I could do with them. However, with the exception of making the LEDs light up like a Cylon’s eyes (or Knightrider’s Kit as per your preference), all my ideas required one spot to be able to talk to another.

So what I figured the first thing to do would be to create a simple way to do this. Basically, each SPOT you want to talk to another instantiates a Buddy object and asks it to look for another buddy (myBuddy.lookForPair()) this will then start the buddy broadcasting and looking for a fellow.

It’s probably important to note at this point that I have not tested this code with more than two SPOTs, I certainly haven’t tested any edge cases where multiple SPOTs start up and all start looking for buddies on different ports. This is code is for my own use, I’m very happy for anyone to download, modify and use it (it is GPL’d) as long as you remember that it only works for the nicest of use cases.

Once two buddies (on different SPOTs) have connected you can send a message from one to the other by typing;

myBuddy.sendMessage("my message");

Recieved messages are handled by a BuddyListener which your SPOT application should have given to it’s Buddy instance. Recieved messages come in from the following method on that interface;

void messageRecieved(String message);

There’s lots of ways this code could be improved, for example the initial broadcast port is hardcoded into the Buddy code itself, this should really be parameterised. Also, the sleeps and waits that the Buddy endures while trying to connect to another one and so on. These should probably be pulled out to fields so that they can be tweaked more easily.

The good thing about this code is that it makes paired communication very simple (although you do have to be careful with the threads that are listening to incoming messages). You can also use your own language/protocol that the SPOTs will interpret on top of this Buddy mechanism very easily.

radio.Buddy – This is the meat of the project. To easily connect two SPOTs each must have an instance of one of these. Once connected to each other sending and recieving messages between the two is very easy.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
package radio;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;

import javax.microedition.io.Connector;
import javax.microedition.io.Datagram;
import javax.microedition.io.DatagramConnection;

import com.sun.spot.io.j2me.radiogram.RadiogramConnection;
import com.sun.spot.io.j2me.radiostream.RadiostreamConnection;
import com.sun.spot.peripheral.radio.RadioFactory;
import com.sun.spot.util.IEEEAddress;
import com.sun.spot.util.Utils;
import com.sun.squawk.util.StringTokenizer;

public class Buddy {

	private static final String NEED_BUDDY = "BUDDY_REQ";
	private static final String I_WILL_BE_YOUR_BUDDY = "BUDDY_ACK";

	private long thisAddressAsNumber = RadioFactory.getRadioPolicyManager().getIEEEAddress();
	private String addyStr;

	private RadiostreamConnection listenOn;
	private RadiostreamConnection sendOn;

	private DataInputStream listenOnInputStream;
	private DataOutputStream sendOnOutputStream;

	private int portOut;
	private int portIn;

	private BuddyListener buddyListener = new NullBuddyListener();

	private int initialBroadCastPort;

	private boolean foundBuddy = false;

	private RadiogramConnection broadcastConnectionIn;
	private DatagramConnection broadcastConnectionOut;

	private int MAX_BROADCAST_SIZE;

	public Buddy(int broadcastPort) throws IOException {
		this.initialBroadCastPort = broadcastPort;
	}

	public void lookForPair() throws IOException {
		IEEEAddress addy = new IEEEAddress(RadioFactory.getRadioPolicyManager().getIEEEAddress());
		addyStr = addy.asDottedHex();

		System.out.println("I am " + addyStr);

		broadcastConnectionIn = (RadiogramConnection) Connector.open("radiogram://:" + initialBroadCastPort);
		MAX_BROADCAST_SIZE = broadcastConnectionIn.getMaximumLength();
		broadcastConnectionOut = (DatagramConnection) Connector.open("radiogram://broadcast:" + initialBroadCastPort);
		startListenForPartnerResponseThread();
		startLookForBuddyThread();
	}

	public void setBuddyListener(BuddyListener bl) {

		if(null != bl) {
			buddyListener = bl;
		} else {
			buddyListener = new NullBuddyListener(); //allows us to reset the currently loaded BuddyListener
		}

	}

	public void sendMessage(String message) {
		if (null != sendOn) {
			try {
				if (null == sendOnOutputStream) {
					sendOnOutputStream = sendOn.openDataOutputStream();
				}
				sendOnOutputStream.writeUTF(message);
			} catch (IOException ioe) {
				System.out.println("IOException sending message on partner stream");
				ioe.printStackTrace();
			}
		} else {
			throw new IllegalStateException(
					"Cannot send message.  No buddy found yet.");
		}
	}

	private void startLookForBuddyThread() {
		Thread t = new Thread(new Runnable() {
			public void run() {
				lookForBuddy();
			}
		});
		t.start();
	}

	private void lookForBuddy() {
		try {
			while (!foundBuddy) {
				Datagram dg = broadcastConnectionOut.newDatagram(broadcastConnectionOut.getMaximumLength());
				dg.writeUTF(Buddy.NEED_BUDDY + " " + initialBroadCastPort);
				broadcastConnectionOut.send(dg);

				Utils.sleep(1000);
			}
		} catch (IOException ioe) {
			ioe.printStackTrace();
		}
	}

	private void startListenForPartnerResponseThread() {
		Thread t = new Thread(new Runnable() {
			public void run() {
				try {
					while (true) {
						Datagram dg = broadcastConnectionIn.newDatagram(MAX_BROADCAST_SIZE);
						broadcastConnectionIn.receive(dg); // blocking call

						String message = dg.readUTF();

						String otherAddress = dg.getAddress();
						long otherAddressAsNumber = IEEEAddress.toLong(otherAddress);

						if (thisAddressAsNumber != otherAddressAsNumber) {
							handleIncomingBroadcastMessage(dg, message,	otherAddress);
						}
						if (sendOn != null && listenOn != null) {

							System.out.println("Buddy status achieved, no longer going to listen to broadcasts");
							System.out.println("Partner port to send on: " + sendOn.getLocalPort());
							System.out.println("Partner port to listen on: " + listenOn.getLocalPort());

							startListenOnPartnerStreamThread();
							break;
						}
					}

				} catch (IOException ioe) {
					System.out.println("Exception when listening for buddy response");
					ioe.printStackTrace();
				}
			}
		});
		t.start();

	}

	private void handleIncomingBroadcastMessage(Datagram dg, String message, String otherAddress) throws IOException {
		if (message.startsWith(Buddy.NEED_BUDDY)) {
			if (null == sendOn) {
				int otherPort = Integer.valueOf(separateStrings(message)[1]).intValue();
				Datagram response = offerToBeBuddy(otherPort, otherAddress);

				response.setAddress(dg);
				broadcastConnectionIn.send(response);
			}
		} else if (message.startsWith(Buddy.I_WILL_BE_YOUR_BUDDY)) {
			buddyInviteAccepted(message, otherAddress);
		}
	}

	private void buddyInviteAccepted(String message, String otherAddress)	throws IOException {
		foundBuddy = true;

		portOut = Integer.valueOf(separateStrings(message)[1]).intValue();
		sendOn = (RadiostreamConnection) Connector.open("radiostream://" + otherAddress + ":" + portOut);

		portIn = portOut - 1;
		listenOn = (RadiostreamConnection) Connector.open("radiostream://" + otherAddress + ":" + portIn);
	}

	private Datagram offerToBeBuddy(int otherPort, String otherAddress) throws IOException {
		foundBuddy = true;

		portOut = otherPort;
		portIn = portOut + 1;

		System.out.println("Offering to be a buddy to " + otherAddress + "\nSending on " + portOut + "\nListening on " + portIn);

		sendOn = (RadiostreamConnection) Connector.open("radiostream://" + otherAddress + ":" + portOut);
		Datagram response = broadcastConnectionIn.newDatagram(MAX_BROADCAST_SIZE);

		response.writeUTF(Buddy.I_WILL_BE_YOUR_BUDDY + " " + portIn);
		listenOn = (RadiostreamConnection) Connector.open("radiostream://" + otherAddress + ":" + portIn);
		return response;
	}

	private void startListenOnPartnerStreamThread() {
		Thread t = new Thread(new Runnable() {
			public void run() {
				while (true) {
					listenForIncomingMessage();
				}
			}
		});
		t.start();
	}

	private void listenForIncomingMessage() {
		if (null != listenOn) {

			try {
				if (null == listenOnInputStream) {
					listenOnInputStream = listenOn.openDataInputStream();
				}

				String message = listenOnInputStream.readUTF();
				buddyListener.messageRecieved(message);

			} catch (IOException ioe) {
				System.out.println("IOException recieving message on partner stream");
				ioe.printStackTrace();
			}
		} else {
			// Maybe we haven't found a partner yet, so don't spin the processor
			Utils.sleep(100);
		}
	}

	private String[] separateStrings(String msg) {
		StringTokenizer stk = new StringTokenizer(msg, " ");
		String[] result = new String[stk.countTokens()];
		for (int i = 0; stk.hasMoreTokens(); i++) {
			result[i] = stk.nextToken();
		}
		return result;
	}
}

radio.BuddyListener – Classes wishing to have a buddy must have (or be) one of these and give it to the buddy instance

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
package radio;

public interface BuddyListener {
	void messageRecieved(String message);
}

radio.NullBuddyListener – It might be that two buddies are connected and one could be chatting to the other which doesn’t have a BuddyListener attached, in which case this is used instead.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
package radio;

public class NullBuddyListener implements BuddyListener {

	public void messageRecieved(String message) {
		System.out.println("Warning!  NullBuddyListener being used and messages are getting recieved");
	}
}

radio.RadioFun – This is included for completeness. It’s the app that got run when I was testing the Buddy connections. I don’t think it makes a lot of sense for any one else to use this class except to see how to talk/listen to the buddy.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
package radio;

import java.io.IOException;

import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;

import com.sun.spot.peripheral.radio.RadioFactory;
import com.sun.spot.util.IEEEAddress;
import com.sun.spot.util.Utils;

public class RadioFun extends MIDlet {

	private Buddy buddy;

	public RadioFun() {
	}

	void start() {
		try {
			buddy = new Buddy(60);
			buddy.setBuddyListener(new BuddyListener() {
				public void messageRecieved(String message) {
					System.out.println("recieved=["+message+"]");
				}
			});
			buddy.lookForPair();
		} catch (IOException ioe) {
			ioe.printStackTrace();
		}

		IEEEAddress addy = new IEEEAddress(RadioFactory.getRadioPolicyManager().getIEEEAddress());
		String addyStr = addy.asDottedHex();

		while (true) {
			try {
				buddy.sendMessage("Hello from "+addyStr);
			} catch (IllegalStateException ise) {
				System.out.println("Failed to send message ["+ise.getMessage()+"]");
			}

			Utils.sleep(500);
		}
	}

	protected void destroyApp(boolean arg0) throws MIDletStateChangeException {
	}

	protected void pauseApp() {
	}

	protected void startApp() throws MIDletStateChangeException {
		RadioFun rf = new RadioFun();
		rf.start();
	}
}

Introduction

Looking back at code I wrote ages ago often leaves me wondering “What idiot wrote this junk?” Looking back through articles I’ve written gives me an uncomfortably similar feeling. Today I’m thinking specifically about multiple return points, which I announced to be the root of much evil in this post. What this post reminds me about most, though, is the Do What Makes Sense principle, something that I’ve often claimed to subscribe to.

How do you plead?

I have to confess my guilt before I can continue. I’ve recently started writing some methods which have more than one return point (and I’m not just talking about exceptions here). But as a kind of mitigation I only use them in very small methods and only sometimes.

Actually that’s not true either.

There is a certain kind of method where multiple return points are acceptable, like these;


public Object myMethod() {
    if(comeCondition) {
        return someObject;
    } else {
        return someOtherObject;
    }
}


Or this one;


public Object myOtherMethod() {
    switch (something) {
        case 1:
            return something1;
        case 2:
            return something2;
        case 3:
            return something3;
        case 4:
            return something4;
        case 5:
            return something5;
    }
}


But in these examples the methods are doing very specific things, most plainly, they return something. No other processing is done. I would still say returns dotted around throughout a method is still a Bad Thing. But that’s not what got me thinking. Whilst trying to justify this use of MRP to myself I started running through the reasons why this code is acceptable, when previously I had said it wasn’t. The switch method above reminds me of some refactoring work I did on my company’s product a while back, and it’s the fallout from that refactoring that I ended thinking about the most.

The Situation

Here’s some background. I work for a company which produces (and uses) it’s own software product, this product allows the buying and selling of Widgets. There are many different places that we can buy and sell Widgets from using our software, there is also a piece of third party software which we must tell who has purchased what Widgets, from whom and how many. The problem comes from the fact that each the objects which represent a user’s Widget-trading position is different for each Widget Gateway. Further, the position objects which we must send to the third party software is fixed. What’s even worse, is that each Widget Gateway can be further subdivided into more specific kinds of Widget Position Objects. Again, it’s even worse than that.

The AcmeWidgetPositionSubA class and the AcmeWidgetPositionSubB class both have the same attributes, but because one is …SubA and one is …SubB, when translating this to a ThirdPartyWidgetPosition the attributes with the same name in the …SubA/B classes will be mapped to different attributes in the ThirdPartyWidgetPosition class.

For example; AcmeWidgetPositionSubA.getSpecialCode() needs to be mapped to ThirdPartyWidgetPosition.getCode(). But AcmeWidgetPositionSubB.getSpecialCode() needs to be mapped to ThirdPartyWidgetPosition.getSystemCode().

This is the scope of the problem and the existing code to do this was lots of lines of if…then…elses to get the right things into the write place before the ThirdPartyWidgetPosition is sent to the third party software for processing. Further, there each subtype of Widget Gateway had it’s own chunk of if…then…else code of varying complexity to get the job done specific to itself. To refactor this code I got rid of all the if…then…else functionality and put all the logic into the type system. By introducing some extra classes that had only overloaded constructors I could remove every occurance of if…then…else, create a AcmeWidgetPositionSubX object, cast it to a ThirdPartyWidgetPosition and have everything in the right place, as if by magic.

So far so good, lots of complex nested branches get removed, all the unit tests pass, everything works, we all go home happy. Now fast forward a couple of months. Someone else is looking at the code and they are struggling to see what goes where and how the branched code has been removed in favour of a clever type hierarchy. Now, let me first explain that it’s my opinion that having the logic inside the type system is a better, actually less complex and cleaner implementation approach than if…then…else. It just feels “more OO”; even if I can’t quantify that phrase particularly well. But to a team member who is more used to seeing and reading if…then…else structures it is not cleaner and more obvious. It’s something that they need to wrestle with and really read in order to understand it.

So if I have slowed down the work of a team member, if I have caused them extra effort to do their own tasks, is my approach still the better one? Even if the code I wrote was the “more correct” implementation; was it the right code to write because of the affect it had on someone else?

Style Over Substance

A few more of my little foibles are using Boolean.TRUE rather than the primative true, and putting the literal I am comparing as the first operand of equals – even though I know that the protection this offers me is irrelevant given I spend most of my time writing Java₁. I know, because I have been told, that some people find these things more difficult to read than their more usual alternatives. Personally I don’t understand why they are more confusing to read. But given that I can read the code quite happily either way and given that the compiler will change my code to whatever it feels like; should I be tailoring my professional coding style so as the most number of team members are happiest reading it?

Drawing The Line

The answer, as everything when discussing ‘programming best practise’, is; “it depends”. In the first example with the types vs if…then…else, that change should definitely be made. I can sit down with you and discuss why it is better, what benefits it has, show you how it is easier to extend etc. And as a consequence of that discussion, the team members who will be reading that code will hopefully start to learn from that example and we’ll be seeing fewer and fewer nested-branched code. Designs will become cleaner and gradually the overall quality of the code across the project will get better.

But what of more style based differences, or indeed, anything else which you can’t prove is a tangible benefit? If they cause pain for other team members or get in the way, then I suggest always defaulting to the lowest common denominator₂. That might be structuring code for the least experienced developer – as long as such structuring does not compromise quality in any way. Or at least, structuring your code so that it is consistent with the rest of the code base. It means shoe-horning your coding style into the style used in the rest of the code base to make it easier to read for the whole team – this is especially true in large legacy codebases.

Doing these kinds of silly superficial things in difference to the rest of the code base is something that I am guilty of, and on reflection, something that I should be trying much harder to put a stop to. Make my code blend more seamlessly into the rest of the code is going to make reading it easier for everyone. But beware, when there is a real change that should be made, for a real reason with benefits that can be quantified I will still argue for that change – even if it’s out of the comfort zone of those around me. And I fully expect, nay demand, that those around make those same kinds of changes to pull me out of my comfort zone – because that’s the only way I’m going to become a better programmer.

There is a lot of talk in various technical blogs about how superstar programmers should be allowed to express themselves in any way, structure their code the way they think it should be done, and basically do whatever they want because (you know) they’re superstars. Most of us are probably not superstars and most of the teams we work in are probably not 100% made up of superstars, so I really don’t find those arguments compelling. What I do find compelling is trying to increase the average code quality and the skill levels of the average (or lowest) team member, and these things are not measured by where they put their curly brackets or whether they use Boolean.FALSE or false. These things are superficial and any non-superficial programmer should be able to get over them.

And let’s not forget; everyone of us is the average-est or the lowest skilled level programmer in the team at something. And even if your team is made up of Superstars, chances are they are not all going to be the same kind of Superstar. Think of your favourite classical music composer, rock performer, rap artist, solo violinist, jazz pianist and so on. Now imagine putting them all in the same band; left to their own devices I really don’t think any music they produce is going to be bearable, let alone enjoyable – and this assumes that they’ll manage to produce anything! Not unless they all agree to do certain things in the same or similar way and all pull in the same direction₃. And I guarantee that each one of them will feel restricted in some way by that. But what they produce will be well worth the Superstar fees they’ll be charging!

Conclusion

It is true that a bit of sand inside an oyster will make a pearl, but a bit of sand inside your shoe is just going to make blisters on your feet. Removing code complexity and builder and more defined cleaner design is a worthy goal and one worth fighting for. But doing what is essentially meaningless things for no tangible benefit is not. As with anything where more than one individual is concerns the rule of give and take must be applied. Forcing your team members to adopt a distorted concept of Hungarian Notation is pointless. Similarly, when such a notation has been adopted and is prevelant in a large percentage of the code base, fighting that notation is probably a hiding to nothing.

Team cohesion is important. Every team will be working better if each member is considerate to the others. By all means bring up the uncomfortable truths and fight to make the design and code better. But if the benefits of what you’re fighting for are not worth the battles to win it, then it’s likely your efforts would be better spent putting for head down and servicing user requests and bug fixes.

1 – Unless I’m comparing booleans, of course.
2 – This is not meant to be a derogatory phrase.
2 – Singing from the same song-sheet even.

A personal article this one…

Rachael gave birth to Esmé Faith this morning (26th July 2008 ) at 4:20 AM BST. She weighed 7lb 2oz, for those looking for metric measurements please go to Brussels where you will (unlike here) be welcomed.

Mother and baby are doing fine. Kate (2 years, 2 months old) is running around saying “You must go to sleep! Don’t wake the baby.” Followed by bellows of “SILENCE!” I don’t know where she got that from.

On a technical aspect, I was impressed with the midwifery team, as soon as the baby was built they ran all the unit tests (developed before the baby was, naturally) and could easily indicate a successful build.

A small subset of pictures is below.

About 15 minutes old

A few hours old

All together at home

Disclaimer

Don’t expect this post to be breaking any barriers. I’ve been struggling with to solve an exercise from my Haskell Road book for the past week or so and I finally cracked it.

I’d be interested to know if anyone has a better way to solve it. I’m still very much a Haskell beginner and haven’t gotten much past pattern matching, guards and the where clause; so try not to confuse me.

The Problem

Create a function

splitList :: [a] -> [([a],[a])]

Which takes a list

[1..5]

and returns a list;

[([1], [2,3,4,5]), ([1,2], [3,4,5]), ([1,2,3], [4,5]), ([1,2,3,4], [5])]

My Solution

moveHeadToTail :: [a] -> [a] -> [a]
moveHeadToTail (xs) (y:ys) = xs ++ [y]

splitList :: [a] -> [([a],[a])]
splitList (x:xs) = splitListAux (x:xs) []

So this year I’m trying to make in-roads in learning some new languages, in particular Ruby and Haskell. My problem is now that since I pay my bills by writing Java code every day I’m left thinking “That’s one line in Ruby” or “Why can’t Java do this like Haskell?”

Without these changes I will spend each day being a little bit more gumpy than is necessary. This is bad because I vocalise my grumpiness. (I like to think of it as contributing to the team.) So if I’m grumpy, I’ll make those around me grumpy. And in turn, they’ll make the ones around them grumpy. So without these changes and with a few more hops like that Kevin Bacon will be grumpy.* So I think that it’s safe to say that even Kevin Bacon want’s these changes. Sun is actually making Keving Bacon grumpy. And that’s not fair.

So here’s a very quick, off-the-top-of-my-head, list of things that I’d like to see in Java. I don’t care if they’re adopted as fundamental language changes or whether they’re just syntactic sugar that the compiler removes and replaces. As long as the changes are made, I’ll be a happy bunny.

Validate Method Parameters

Like a good boy I always check my method parameters before I can use them. Most of my checks are boring and repetative, they clutter up my super-important-and-complicated business method. Why can’t they be moved out to annotations?

Code Like This…

public String complexMethod(Object someObj, String someStr, int number) {
  if(null == someObj) {
    throw new IllegalArgumentException("someObj cannot be null");
  }
  if(null == someStr || 0 == someStr.trim().length()) {
    throw new IllegalArgumentException("someStr cannot be null or empty");
  }
  if(MIN > number || MAX < number) {
    throw new IllegalArgumentException("number out of range");
  }

  // Complex code goes here
}

Is Replaced With…

@Check(NOT_NULL, IllegalArgumentException, someObj, "someObj cannot be null")
@Check(NOT_EMPTY, IllegalArgumentException, someStr, "someStr cannot be null or whitespace only")
@Check(IN_RANGE, com.mycompany.BadNumberRangeException, number, MIN, MAX)
public String complexMethod(Object someObj, String someStr, int number) {
  // Complex code goes here
}

Wrap Methods in Try-Catch

Many times a day I see code where the entire method is wrapped in a try-catch statement. Often times the stuff in the catch statement is repeated though the class (or classes). Another annotation could remove this noise and make the business code look much more plain.

Code Like This…

public void doDatabaseThing() throws SQLException {
  try {
    // some database thing
  } catch (SQLException sqle) {
    methodToRun();
  }
}

Is Replaced With…

@IfThrown(java.sql.SQLException, methodToRun)
public void doDatabaseThing() throws SQLException {
  // some database thing
}

Maybe a better approach is to abolish all checked exceptions, but that’s another post.

What was the index, please?

Java’s for-each loop is just syntactic sugar for a normal for loop, complete with counter. Why couldn’t they introduce a Perl-esque special variable that had the current iterations index in it? For example;

for(String name : names) {
  System.out.println(name + " is at index " + $_);
}

Controvertial: Easily implement the decorator pattern

Sometimes you need to wrap objects in other objects. Fine. Sometimes you can’t use a simple “extends” and just override the methods you’re interested. Annoying. But what happens when the object you want to wrap has an enormous public interface? You can argue that this is implying you have a bad object model, and I probably won’t disagree, but sometimes you just have to play the cards dealt you and that means wrapping something with a big public interface.

Code Like This…

public class Wrapper {
  private Wrapped wrapped = new Wrapped();
  public void method1() {
    wrapped.method1();
  }
  public void method2() {
    wrapped.method2();
  }
  public void method3() {
    //do something different first...
    wrapped.method3();
  }
}

Is Replaced With…

@Decorates(wrapped)
public class WrapperClass {
  private Wrapped wrapped = new Wrapped();
  public void method3() {
    //do something different first...
    wrapped.method3();
  }
}

…and have the compiler fill in all the boring pass-through methods for me.

Pattern Matching

I really like the pattern matching of methods you get in Haskell and I’m left wondering if Java might benefit from them to.

Code Like This…

public void doSomething(boolean flag, Object otherArg) {
  if (flag) {
    // some code here
  } else {
    // other code here
  }
}

Is Replaced With…

public void doSomething(Boolean.TRUE, Object otherArg) {
    // some code here
}
public void doSomething(Boolean.FALSE, Object otherArg) {
    // other code here
}

But I really don’t know if this makes things more simple.

In Closing…

I haven’t actually done much (read: any) research into how to write my own annotations in Java. I really don’t know how to write an annotation that will make the compiler behave differently and inject code into the source. I’d be interested to hear if anyone knows where I can do some reading on this.

* Okay, so it’s not a perfect application of 6-degrees, so what?

Edit: I’ve just read this (pdf) and found it really helpful explaining some of the concepts I’ve been wrestling with

I’m working my way through The Haskell Road to Logic, Maths and Programming to try and get a better understanding of functional programming and all the things that that entails.

Sadly, I’m hitting problems. The programming problems I’m okay with, I can run the code and see if the result is was I expect it to be. But I’m struggling with the proof-based exercises. I can contact the authors here but I don’t want to get a list of all the answers – mostly because I’ll know I’ll start cheating if I have them! So I’m stuck trying to work out if what I’ve done is correct.

That’s where this blog comes in, maybe I’ll get some comments from people telling me what I’m doing wrong…

Exercise: 3.5.1 (Page 83)

Show that from P <=> Q it follows that (P => R) <=> (Q => R)

Major edit alert!

After lots of reading and help I’ve reached a conclusion. There’s an easier way to write proofs using actual sentances! Also, for this first exercise there are two ways to do it, the first which is what I originally tried to say (but got wrong) and a second which Kim-Ee Yeoh helped me reach in the comments.

My Way

We are given P <=> Q, so we know that this is True. For this to be True the following two statements must also be True.

• P => Q
• P <= Q

For these two statements to be True, P and Q must also be True.

Because we know that P and Q are True, we can take these as new givens and use the Reduction Rule on both sides of the <=> in the statement we’re asked to prove. So;

• P => R becomes R (using the Reduction Rule and our knowledge that P is True)
• Q => R becomes R (using the Reduction Rule and our knowledge that Q is True)

Now I’m a bit stuck, now I have to prove R <=> R and the only thing that tells me that this is True is my intuition, which can rarely be trusted. I can break it into two peices (as above for the oriignal given) and prove R => R and R <= R, which should leave me concluding that R is True. Right?

Kim-Ee Yeoh’s Way

Part 1: Copied from the comments below

Assume Q => P and P => R. We want to show Q=>R. It suffices to show that if Q is true, R must also be true. So let’s assume Q is true. Then Q=>P forces P to be true. In turn P=>R forces R to be true. Done.

Part 2: All my own mess

Assume P => Q and Q => R. We want to show P => R. It suffices to show that if P is True, R must also be True. So let’s assume P is True. Then P => Q forces Q to be True. In turn Q => R forces R to be True. Done.

Part 3: Mess continuation, a step to far?

The above two sub-proofs mean we can rewrite the original statement to be proved as True <=> True, which again boils down to True.

Now I’m sure I’ve got something wrong, because it seems too easy. Also, writing out these two approaches one after the other makes me think that they are basically the same, is that a correct thinking?

Exercise: 3.5.2 (Page 83)

Show that from P <=> Q it follows that (R => P) <=> (R => Q)

We are given P <=> Q, so we know that this is True. For this to be True the following two statements must also be True.

• P => Q
• P <= Q

For these two statements to be True, P and Q must also be True.

Because we know that P and Q are True, we can take these as new givens and use the Reduction Rule on both sides of the <=> in the statement we’re asked to prove. So;

• R => P becomes R => T
• R => Q becomes R => T

Looking at the Truth Table for =>, ? => True is always True, so the original statement we need to prove can be rewritten as True <=&gt True, which again boils down to plain old “True”.

I guess what I’m trying to say is, given my lack of confidence in this area, can someone who knows more than me about this stuff help me work out if I’m doing it right? A thousand “Thank You”s in advance.

Edit: I must say a big thank you to Kim-Ee Yeoh for the comments he left, I found them really useful!

So continuing my Ruby on Rails adventure it seems I have hit another problem. Luckily this one seems quite easy to fix, although it did take me a good old time to find the solution.

Maybe it’s also obvious to everyone else in the world and it was only me that was stuck, but maybe not. So I’m sharing this here to help others who might be interested.

The Situation

I have two models, Products and Categories. Products belong to a Category. So when searching for all the Products for a given category I have the following ruby code in my controller;

def show_category
  id = params[:id]
  @category = Category.find_by_id(id)
  @products = Product.find_by_category_id(id)
end

What I’m expecting is to return a list of Products to my view, all of which belong to a category.

The Problem

But instead I was getting the following error;

undefined method `each' for #

For this view code;

<% for product in @products %>

The Solution

I worked out that this is because for the data I was testing only one product was being returned from the find method. This was correct behaviour because there was only one product in the data. But that meant that a single Product object was being returned, not a Collection containing a single Product object. So change the controller to look like;
def show_category
  id = params[:id]
  @category = Category.find_by_id(id)
  @products = Product.find_all_by_category_id(id)
end

And a collection is always returned, even if there is only one Product. Problem solved.

Introduction

For myriad reasons I’ve decided to start writing my own website and I’m doing that using Ruby On Rails. Unfortunately I hit a snag. I wanted to secure some parts of the site using SSL whilst leaving others open. To do this I needed to, among other things, front the rails server (in my case that’s WEBrick) with Apache and have the later do the proxy pass through magic.

I spent a lot of time in search engines reading various different articles trying to work out how to do this, but not matter which instructions I followed I couldn’t manage to get it to work. I did eventually find a solution though. This article is just to detail that solution so others don’t have to do the same level of research and gnashing of teeth that I did.

Before I forget, these instructions work on my reasonably clean Ubuntu Gutsy install running on my Rizeon (actually a Compal IFL90) laptop. which reminds me… If anyone out there has an IFL90 which they’re having Ubuntu trouble with I recommend Louis-Dominique’s site which gave me a lot of good pointers.

Assumptions

I’m assuming that you’ve installed RoR and Apache2 using your preferred method. These instructions are all about getting them to play nicely together.

SSL Certificate: Self Signing

Because my application is in development mode I just need a certificate to test with, which is where self-signing comes in. See the instructions on this page on how to download and create a self-signed certificate.

Apache2: Enabling the mods

Now, I didn’t download anything extra when I used apt-get to install Apache2, so it’s my belief that it downloaded the list of following mods when Apache was installed. Therefore, I also believe that all you need to do is enable them.

The following incantations will do the enabling, if you get errors because certain mods are missing from your install then I’m afraid that you’re going to have to find out how to install them on your own, sorry.

$ sudo a2enmod ssl
$ sudo a2enmod proxy
$ sudo a2enmod rewrite
$ sudo a2enmod proxy_balancer
$ sudo a2enmod proxy_http
$ sudo a2enmod headers


Apache2: Setting up the VirtualHost

We need to set up some virtual hosts for Apache to represent our proxied site. I also disabled the default proxy application. Here’s the commands needed, instructions follow.
$ cd /etc/apache2
$ sudo a2dissite default
$ sudo cp sites-available/default sites-available/myapp
$ sudo a2ensite myapp


Where “myapp” is obviously the name of the application I’m trying to set Apache up as a proxy for. The “a2dissite” command disables the default web application inside Apache, and the “a2ensite” command enables our one. I copied the sites-available/default file into sites-available/myapp to make sure that the new file describing myapp has the correct permissions etc. We’ll be scrubbing the contents of this new file completely in the next step.

Still in the terminal and still in the /etc/apache2 directory we need to modify our sites-available/myapp file, which we need to do as route, so obviously using your text editor of choice…;
$ sudo vi sites-available/myapp


Below if the contents of my file, feel free to copy it.

<VirtualHost *:80>
  ServerName localhost
  ProxyPass / http://localhost:3000/
  ProxyPassReverse / http://localhost:3000/
</VirtualHost>

<VirtualHost *:443>
  ServerName localhost
  ProxyPass / http://localhost:3000/
  ProxyPassReverse / http://localhost:3000/
  ProxyPreserveHost On
  RequestHeader set X_FORWARDED_PROTO 'https'

  SSLEngine On
  SSLProxyEngine On
  SSLCertificateFile /etc/ssl/certs/selfsigned.pem
  SSLProxyMachineCertificateFile /etc/ssl/certs/selfsigned.pem
</VirtualHost>

Now I’m the first to admit that I don’t 100% understand what the RequestHeaders line is for. It’s my understanding that because Rails doesn’t have a concept of http/https this line overrides some functionality in the link_to code so the correct “http/https” is appended to the URL as required. But as I say, I’m not totally sure that my understanding is accurate in any way.

Apache2: proxy.conf

We need to configure the apache proxy behaviour. To do this we have to modify the file /etc/apache2/mods-available/proxy.conf We need to tell Apache where to accept proxy requests from. Here’s the snip of my proxy.conf file which allows proxy-ing from localhost.
</Proxy *>
  AddDefaultCharset off
  Order deny,allow
  Deny from all
  Allow from localhost
</Proxy>


We now need to bounce Apache2, so issue the following command;

$ sudo /etc/init.d/apache2 force-reload

You shouldn’t get any errors when Apache2 restarts. If you do, either you’ve not followed the above instructions properly or, more likely, I’ve forgotten a critical part of the instructions. If it’s the latter, please let me know of any problems and I’ll rack my brains (and chalk my nose) and get the missing pieces put up.

Rails: Last Stages

Now, as I mentioned earlier, WEBrick doesn’t understand the concept of SSL but Rails/Ruby needs to know to block requests coming in on HTTP when they should be on HTTPS and to do the appropriate redirects. We do this using the ssl_requirement package…

$ cd ~/myapp
$ ruby script/plugin install ssl_requirement


And now we need to modify our controllers to force this usage. In my setup I have an AdminController which all my, er, administrative controllers extend. This means that I just need to apply a layout to my AdminController to get all the admin-stuff looking the same, it also means that I can modify this controller with the SSL stuff and have that ‘cascade’ down to the other more specific admin-y things. here’s my AdminController…

class AdminController < ApplicationController

$nbsp;$nbsp;include SslRequirement

$nbsp;$nbsp;layout 'admin'

$nbsp;$nbsp;# all methods that extend AdminController should use SSL
$nbsp;$nbsp;def ssl_required?
$nbsp;$nbsp;$nbsp;$nbsp;true
$nbsp;$nbsp;end

end


I’ve overridden the ssl_required method because I want all methods of my admin controllers to use SSL. If you want to be a bit more specific on which methods in a controller need SSL I suggest no overriding this but following the example which you’ll find in ~/myapp/vendor/plugins/ssl_requirement/README

Now start WEBrick in the usual way. If you then browse to http://localhost you should get the default non-ssl rails app you were expecting. But if you browse to a URL which should be on SSL you’ll find you get redirected. So in my case; http://localhost/admin redirects me to https://localhost/admin and from then on all URLs and clicks that should be done on HTTPS are where as all non-secure stuff is done on regular HTTP.

Conclusion

I hope that someone finds these instructions helpful. I’m by no means an expert, I got here just by piecing together instructions found on other sites. But if there are any problems let me be the first to say it works on my computer please post a comment if these instructions don’t work and I’ll do my best to help.

References

For the sake of completeness and politeness below is a list of all the pages I used in getting my install working. I’m sure that you’ll find some (or all) of the commands I’ve listed here on these other pages.

• http://www.urbanpuddle.com/articles/2008/01/09/install-ruby-on-rails-on-ubutu-gutsy-gibbon-apache-version
• http://rikkus.info/apache2-in-front-of-rails-on-debian.html
• http://craiccomputing.blogspot.com
• http://articles.slicehost.com/2007/11/26/ubuntu-gutsy-apache-ssl-and-vhosts
• http://articles.slicehost.com/2007/11/26/ubuntu-gutsy-generating-a-self-signed-ssl-certificate

Also, apparentlybecause-let-s-face-it-webrick-sucks. I personally haven’t encountered the same problems that the author has, but in case you have the article has some good instructions on how to install an alternative called Mongrel. I might give that a try later.