I know, a thousand CDs… I wasn’t always married, you know.

So. What did I to do? I can’t afford to make the house bigger and I can’t persuade my wife to even consider using the shed out in the back garden as a nursery, so I had to bite the bullet and store them all as MP3’s and listen to them (somehow) over the network.

When I started this, I had a few requirements:

1. I didn’t want to have a computer switched on in order to listen to music.
2. It couldn’t cost an arm and a leg.

That was pretty much it.

I didn’t want to leave a computer on all the time, ’cause I’m pretty tight and don’t fancy the idea of my electricity bill going through the roof, also, even ‘though my wife has a masters in computer science, it’s very much in the “science” end of the spectrum, and so doesn’t know all that much about computers, and I didn’t want her to have to deal with switching on two things just to listen to some music.

I figured that these were pretty reasonable requirements, but they threw up some pretty hefty brick walls, but like Randy Pausch said: “Brick walls are there for a reason. They let us prove how badly we want things.”

And I didn’t want to spend too much money… really badly.

Eventually, after much searching, I decided upon this setup:

• I store my music on a NAS drive that’s plugged straight into my wireless router.

The benefit of this is that it’s sitting there all the time, and hardly drawing any power at all, unless its being used. I chose the half-terabyte Buffalo LinkStation Live. I could have gone for a simple external hard drive at half the cost, and just plugged it into the media server, but everyone I know who bought an external hard drive, and moved it, had a broken external hard drive in about a year and a half. This is because external hard drives, for reasons i don’t understand, don’t come with fans, and so tend to be a bit brittle.

Also, I didn’t want all of my music sitting on a hot external hard drive within reach of my daughter’s clumsy, sticky hands.

• I stream my music through a media server, that I’m also using as a DVR to store TV.

It’s funny, but every audio-only media server i could find cost an absolute fortune, so I went for a more general media server in the Neuros OSD. It’s open-source, and so it’s a little rough around the edges, but it does everything that I need it to.

There is a slight niggle with it, in that it doesn’t come with a wireless antennae, so, rather than run cat-5 cables all over the house, I got a ethernet-wireless bridge. The first one I got was the god-awful D-Link DWL-G810 802.11g Wireless Bridge, that I won’t bother adding a link for because even ‘though the website said it supported WPA, their support said it didn’t (I got my money back on that one). After that debacle, I went for another Buffalo product: their Wireless Media convertor. It was cheaper than the D-Link, and had the added bonus of working.

• I rip my CDs to a “high enough” quality.

You don’t get to own a thousand CDs without becoming an elitist music snob. I know this about myself, and I wasn’t going to let my snobbery fool me into ripping my CDs in a completely lossless format unless I could actually tell the difference between FLAC and MP3 encoding.

So I did a few experiments: I ripped a few albums in different formats (FLAC, MP3 96K, etc), mixed the songs up so I didn’t know which format was which, and then listened to them all a few times, trying to guess which song was in which format.

Hey, I have a science degree, and this was my first chance to do a double-blind test, so I was going to take it.

Anyway, it seems that I have a good enough ear, but not fantastic, in that I can spot the lower quality MP3 encodings easily enough, but towards the upper end I’m right only about 60-70% of the time, and when I get to 320K VBR and FLAC, I’m right about half the time (i.e. I can’t tell them apart).

The upshot of all of this is that I’m ripping my CDs as 224KBs VBR, (my double-blind test showed that I can’t really tell these apart from FLAC with any real consistency) which means the half-terabyte NAS drive should be big enough to store this all with plenty of room to spare.

• I rip my CDs with a good tool.

I’m using Exact Audio Copy for this. They describe their tool pretty well, but simply put, it gets you a good copy of the music by repeatedly checking sections of music that it thinks “smells” a little, until it thinks it has gotten it right. It’s slower at ripping than your usual tool, but I figured that once my CDs are in the attic they won’t be coming down again, so I want as good a soft copy as I can get.

EAC is quite configurable, but I’ve gone with the flow and am using LAME as my MP3 encoder.

• I’m managing my media with a single, good, tool.

There are so many media tools out there and I just wanted one that was small and light. My PC is four years old now and after years of upgrades it’s starting to show its age, so something like iTunes was going to be way too heavy for my liking.

In the end I let file hippo point me towards media monkey; partly because it’s small and light and fast, and partly because I really like monkeys.

And that’s pretty much it. The Neuros is working like a charm, although I’m running it with a beta firmware, because the latest official one has some niggles I’m not too fond of (I said it was a little rough).

All I need to do now is find a cable splitter so I can pipe the sound from the Neuros through my stereo, since I don’t like having my TV on all day just so I can listen to music (I said I was tight).

Oh yeah, and I need to rip all my CDs. It’s quite interesting to listen to music alphabetically, but I’m only as far as Bach.

You can find it here http://www.danielbray.com/php/keygen

Enjoy.

Well, if you’re running your application in eclipse, you might be able to try out your fix first, without needing to redeploy everything to find out that you were wrong, ’cause lets be honest here, the first time you try something, it usually blows.

How? This is easiest done with an example:

Consider this “application”

public class Plaything {
  public static void main(String[] args) {
    for (int i=0; i!= 5; i++) {
      doIt("monkey");
    }
  }

  static void doIt(String primate) {
    System.out.println(primate);
  }
}

If you run this, it will output the following:

monkey
monkey
monkey
monkey
monkey

Now, suppose you find out during debug, that you set the wrong parameter, and that perhaps the word “monkey” shouldn’t have been in there, and you want too see what would happen if you had passed a different parameter into doIt(String), “gorilla” perhaps.

What you can do is this:

• Set a breakpoint on the first line of doIt.
• Right click the breakpoint, and edit the “Breakpoint Properties”
• Check the “Enable condition” checkbox, and drop in the following code

primate = "gorilla";
return false;

What we’re trying to do here is invoke some code in the breakpoint condition, every time eclipse gets to this point, but to make sure that the debugger doesn’t stop the execution. It works because of the following:

• You can execute any code fragment you want in here, so long as the java is correct and the variables are in scope. In this case we change the value of the “primate” parameter, but you can pretty much do whatever you want, although inside of inner classes the parameter/field names will not be the same as they appear in code.
• The return false; is important, it’s there so that the condition is never true, and so eclipse won’t stop on the breakpoint. If we returned true from this fragment then eclipse would stop on this breakpoint every time we hit it, and that’s what we’re trying to avoid.

The output of this code is as follows

gorilla
gorilla
gorilla
gorilla
gorilla

Is that all you can do? No wait… there’s more. Here’s a more complicated “application,” it’s so complicated that it breaks.

/**
* A simple enough class to demonstrate what
* we can do with breakpoint fragments
*/
public class Plaything {
  /**
  * A string value for later comparison. It's private
  * with no accessor, so I'll be forced to do some gymnastics
  * to get at it.
  */
  private String primate;

  /**
  * Create and populate the primate with the constructor
  * @param primate
  */
  Plaything(String primate) {
    this.primate = primate;
  }

  /**
  * Is the candidate string the same as the one we
  * passed in the constructor
  * @param candidate
  * @return
  */
  boolean isSame(String candidate) {
    return primate.equals(candidate);
  }

  /**
  * This will fail on an NullPointerException
  * because we created the plaything with a null
  * field
  * @param args
  */
  public static void main(String[] args) {
    Plaything plaything = new Plaything(null);
    System.out.println("Is it a monkey? " + plaything.isSame("monkey"));
    System.out.println("Is it a gorilla? " + plaything.isSame("gorilla"));;
  }
}

We create a Plaything with a null primate, and then later try to compare this with “monkey” the result is the all too familiar.

Exception in thread "main" java.lang.NullPointerException
  at com.braindelay.Plaything.isSame(Plaything.java:39)
  at com.braindelay.Plaything.main(Plaything.java:50)

Now, suppose we put a breakpoint on this line:

System.out.println("Is it a monkey? " + plaything.isSame("monkey"));

… and added this breakpoint condition

java.lang.reflect.Field field = Plaything.class.getDeclaredField("primate");
field.setAccessible(true);
field.set(plaything, "gorilla");
return false;

If we run this in debug mode now, we get the following output:

Is it a monkey? false
Is it a gorilla? true

Now, I’m aware that since Plaything is in the same class as the main operation, so we could have just accessed primate directly, but I was trying to make a point here: the code fragment that you put into the breakpoint condition can be pretty much anything you want; just make sure you return a false at the end of it.

So, the object of this lesson is that although you’re eventually going to have to fix the code properly, you can try things out on a running system without needing to take it down and recompile it to do so.

Enjoy.

Once I figured out what I wanted to do, I guess I had to figure out how I was going to do it.

• InstantRails: kind of like xampp, but for rails. It’s a simple-to-use installation of rails that comes with a deployment of MySQL that works out of the box. I’ve been playing with this for a while now and it’s pretty easy to use. So easy, in fact, that it just worked without my needing to do anything.
• I do my actual coding in eclipse, using these two ruby plugins:
• RDT: update site (http://updatesite.rubypeople.org/release).
  
• RadRails:update site (http://radrails.sourceforge.net/update).
• I’m doing my user authentication with the LoginGenerator gem.

I keep track of any other bits and bobs I find interesting on this subject in del.icio.us at http://del.icio.us/braindelay/ruby.

I guess the first thing you need to do before you do something is decide what it is you want to do.

That sounded a bit like humpty-dumpty, didn’t it.

Anyway, I wanted to do something realistic, so I would have to learn how real programs work, and also something with a little twist, so that there would be some actual coding involved, and not just a lot of integration.

I’ve also decided, when this is all over, to push this up onto sourceforge, ’cause I figure that if this open source it’ll force me to try to write good code, rather than cheap, and nasty hacks, just to get it finished.

What I’m not trying to is come up with anything new, so, well, I’m writing a kind of collaborative blog. Right now, I’m thinking of calling it cauliflower, but I’m not married to it.

I really hate cauliflower.

So, what do I mean by collaborative blog?

I mean this:

1. Anyone can read it and sign up to write to it.
2. Each user has their own personal blog, and all posts are open to comment by other signed-up users.
3. When a user writes a post, or makes a comment, then that document will be marked with one or more tags (very web 2.0).
4. When a post or comment is rendered by the blog, then any word in that document that corresponds to any tag (created by any user) will link to the results of a search of all documents created with that tag. The results can be sorted by:
1. Most recently added document first.
2. Most read document first.
3. The document which was written by the most active user first. By active I mean who writes the most documents on this topic.
4. The document which was written by the most read user first. By most read, I mean which user has written the most documents on this topic, and that have been read most.
5. The home page will be split up into three sections: posts; users; tags.
1. Posts can be sorted:
1. Most recently added first.
2. Most read first.
3. Most popular author first.
4. These searches can also be filtered by topic (i.e. tag).
5. Clicking a post will take you to that post.
6. Clicking a comment will take you to that comment.
2. Users can be sorted:
1. Most read first.
2. Most active first.
3. These searches can also be filtered by topic (i.e. tag).
4. Clicking a user will take you to their personal blog.
3. Tags can be sorted by:
1. Most recently added first.
2. Most popular (over all time).
3. Most popular (today, last week, last month, last year).
4. Clicking a tag will take you you the same search results that the in-document link would take you to (see 4. above).
6. From the main page you will be able to search posts by tag. The tag search will be sortable in the same way as the in-document link results (see 4. above).
7. From the main page you will be able to search posts by plain text. The results will be sortable by:
1. Best match (exact string match/most words/best hit count).
2. Where many documents are matched, order them by the most popular author of those documents’ topics (i.e. who has written the most popular documents in that topic). This could be tricky.

So, the plan is to create a big matrix of interconnected documents, where the search attempts to take you to the user who is the most active and most popular author in that field.

Personally, I’m no fan of wikipedia, so as a tool I would have no respect for this in the real world. I think democracy is not good for expertise; mediocrity maybe, but not expertise.

Still, it’s a hard enough project, so by the end of it I should know what I’m doing.

So, the plan is to do some kind of automatically cross-referenced bloggy/wiki kind of thing; where people can log in, create/edit articles, give these articles tags, and then, whenever any article contains these tags, have them link automatically into each other.

I figured that this would be simple enough that it wouldn’t take too long to do, and be complicated enough that I would actually learn something from it, namely:

• User management.
• Session management.
• Database management.
• And some (slightly) complicated GUI rendering.

I figured that this would be enough to be getting on with, and that I should have some idea of how Ruby on Rails works.

As I go along, I’ll be keeping track of any interesting Ruby/Rails links I find on http://del.icio.us/braindelay/ruby, but for now, this is what I’m looking at to do this:

• InstantRails is a bondoogle that will allow you to get up and running pretty quickly, and will have you writing your hello world in about five minutes.
• OnLamp have a good tutorial called Rolling with Ruby on Rails that’ll have you doing database interactions five minutes later.

Thats all for now, I don’t have a design in my head for this yet, but I do have requirements (kind of) which is always a good start.

I got a broadband a while back, and it came with a wireless router, which was just enough to tip my natural anxiety over into full-blown paranoia.

So, I spent a bit of time investigating how safe I could make my router and I came up with the following. I won’t go into too much detail, because people who know more about this have already done that here, and here.

First you need to hide your SSID and limit your network access to specific MAC addresses. This won’t do a huge amount to protect your network, but it will, at least, prevent your neighbours from using up your bandwidth since it would only take a wireless-enabled laptop to be switched on near your router for your network to be compromised. It’s not a real safety measure since the wi-fi protocol requires that the SSID be broadcast occasionally, and it’s actually pretty easy to sniff this out and instruct your network card to identify itself with a different MAC address.

So the only real way to secure your network is to encrypt the traffic so that nobody can read what your up to, won’t be able to read your personal data and won’t be able to join your network.

If you’re doing this at home (as I am) then you’re pretty much going to be restricted to using either WEP or WPA-PSK. Both are crackable, but WEP is fundamentally flawed, whereas WPA-PSK is only really broken if your pre-shared key is too small. You’re going to hear a lot of noise that WPA-PSK is “easy” to crack, but if you do it right you’re pretty safe.

If your pre-shared key is “presharedkey” then you deserve whatever you get.

So, what’s a good pre-shared key? It’s simple enough: it needs to be as long as possible, from as large an alphabet as possible, and to be as random as possible.

What you don’t want to do is to use anything approaching a natural language, there are too many tools out there like john the ripper that are just far too good at breaking keys like this. Luckily, a network pre-shared key doesn’t need to be able to be remembered: you’re not going to be typing this in every time you “log in,” you’re only going to have to type this in once when you set up your network connection.

So, what to do? First you need a whole bunch of random numbers. That is, real random numbers, and not numbers generated by software (they’re not really random). I get my random numbers from http://www.random.org, who get their random numbers by pointing an antenna at the sky and reading the satic, which is about as random as you can get.

The next thing to do is to turn these numbers into a string that you can paste into your router/clients. I did it with a bit of java. It’s in java 1.5, but if you use earlier versions there’s only the tinest bit of auto-boxing, so it’s trivial to retrofit it.

The first thing I needed to do was to get random.org to give me the numbers I needed in as simple a format as they could. Luckily, it turned out to be trivial to get it to return a plain list of numbers, one per line. All I needed to do was to open the following URL and read what it gave me.

http://www.random.org/cgi-bin/randnum?num=100&min=1&max=10&col=1

The above example will return 100 numbers (num=100) between 1 (min=1) and 10 (max=10). It was a simple task to get this to return the numbers I wanted. All I had to do then was to figure out what were the numbers I wanted.

The best advice I can find out there is that the pre-shared key should be at least 20 characters, but if you make it longer you should: I made mine as big as I could, at 63 characters. The next thing I needed to worry about was how to turn these numbers into a string.

This is very easy, it’s just case of turning these numbers into ASCII characters. I wanted to make my pre-shared key as complex, and as hard to crack as possible, which meant I needed to make the alphabet as larges as possible. This turned out to be all the characters between 33 (”!“) and 126 (”-“), but your own router might not allow this range.

So, first you need to create your URL to poke at random.org.

// how long should the password be
int passwordLength = 63;

// What's the minimum ASCII character allowed in the password
int minCharacter = 33;

// What's the maximum ASCII character allowed in the password
int maxCharacter = 126;

// this URL will return a plaintext page of numbers, between
// min and max, one per line
String unformattedUrlString =
"http://www.random.org/cgi-bin/randnum?num={0}&min={1}&max={2}&col=1";

String formattedUrlString = MessageFormat.format(
unformattedUrlString,
new Object[]{
passwordLength,
minCharacter,
maxCharacter
}
);

URL url = new URL(formattedUrlString);

Now you want to open a connection to this URL, read the data, and turn it int a list of numbers.

private List getNumbers(URL url) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(url.openStream()));

List keyElements = new ArrayList();
while (true) {
final String read = in.readLine();
if (read == null) {
break;
} else {
int value = (int)Integer.parseInt(read);
keyElements.add(value);
}
}

return keyElements;
}

Now you want to turn this list of numbers into a string.

private String getPasswordFromNumbers(List elements) {

StringBuffer buffer = new StringBuffer();
for (Integer element : elements) {
char character = (char)element.intValue();
buffer.append(character);
}

String password = buffer.toString();
return password;
}

This pre-shared key is strong. At 94⁶³ combinations (that’s about one and a half times as many protons and neutrons there are in the whole universe) it’s stronger than anything you’re ever liable to actually need, so until someone finds the same kind of deep flaw in WPA-PSK that they found in WEP your network encryption should be good enough to be getting on with.

If you don’t want to go to the effort of writing this up yourself then you can grab the wpa.jar from here. The jar contains the source and the javadocs too. If you want to run it, then just go:

java -jar wpa.jar

The output is like this:

cnMpO'5s:_=?[z42L25C`Sro"~ke27

Enjoy your safe networking! Let me know how it works out.

Object-oriented programming: rarer than you think