Having leeched the StackOverflow community for the first three years of my degree I decided it was time to give something back. This was the single best self development decision I have ever made.

I have learned more from answering SO questions over the last few weeks than I’ve learned in the last few years of my degree. As an example, here’s a question from the other day that I answered. The original question (found here) was this:

I have a task in which I have to read data using different threads.

The problem is that due to the limitation of read rates, I built different threads with thread groups.

Can any one tell me how to sleep one entire thread group so that it begins execution from exact same place where it left and the other thread groups remain executing?

Not a very normal problem, obviously Threads should not be controlled like this. However, trying to be helpful I hastily answered:

Is it enough to enumerate the Thread group and call sleep on each thread?

1 2 3 4 5 6 7 8 9 10

// initialise the ThreadGroup with Threads ThreadGroup tg; // initialize an Array to hold enumerated Threads Thread[] threadsToSleep = new Thread[count]; // Copy thread references into array tg.enumerate(threadsToSleep); // Sleep each thread for specified time for (Thread t : threadsToSleep { t.sleep(sleepTime) }

That sounds simple enough. However, had I thought about it for more than a minute I would have realised a debilitating flaw, which was instantly pointed out to me by the comment:

Sleep is a static method. You will sleep the current thread and not the thread you’re iterating on – John Vint

Duh. Of course Thread.sleep() is Static and my answer is useless.

My idiocy aside, the point I’m trying to make is that my quick humiliation on this question means I will never forget my mistake.

I need not point out the usefulness of this. It’s even suggested that high StackOverflow reputation will help you stand out to employers and is a great thing to include on your resume.
So what are you waiting for? Start answering questions too!

The project itself is based on JavaScript and I’ve decided that I will share several problems I’ve encountered and my own thoughts on the language over the next few months. When my project is finally complete I will be releasing it under the Creative Commons license for others to explore.

It’s very exciting (at least for me!) so stay tuned for updates! Time to get back to work…

Anyway, as per usual we have a problem with me trying to SSH around his routers closed and forwarded ports. This got me thinking about reverse SSH tunneling and if we could use my VPS as a middle man.

Through some Googling I found the SSH option -R which allows you to bind a port on the remote server to a new host.
So let us run this command on the machine we are trying to reach, our destination machine, using my VPS (ivings.org.uk) as the middle man:

This opens and binds port 10022 on the VPS for listening, and all connections on that port are forwarded to port 22 of our destination.

Now if I ssh to the VPS:

Then connect to the tunnel port:

Where `user` is our username for the destination, then we should be logged on through our tunnel, bypassing the destination machines firewall and NAT.

If you want to add extra security, then this situation should work fine with normal ssh keys instead of passwords.

Obviously I had put off upgrading long enough, so went searching on the best way to migrate to the newest version. The first command I found seemed pretty simple;

This should automagically download the latest kernel source and upgrade all packages to the newest supported version, awesome. However, if it was that simple then I wouldn’t be blogging about it right? Right.
It appears that this command gets deprecated when you fall more than one version behind. So although it can be used effectively to upgrade from Karmic to Lucid, it doesn’t work when upgrading from Jaunty. For reference, the the command gives the following output:

In order to pull this off we firstly need to upgrade to Karmic. Luckily there is a small hack that allows us to upgrade all our packages to Karmic versions, including the kernel.
Edit the apt sources list so that it looks like this:

Now, if we run a system upgrade, all Karmic packages will be downloaded and installed, including the new kernel.

Now we are running Karmic we can upgrade to Lucid using:

Hopefully you should not have any issues with this, but I had a couple with the old kernel files.
Explained by this StackOverflow post by me, I was stuck with some old kernel modules that would not uninstall because the kernels no longer existed. This was giving me this error message every time I ran apt:

Thank god for StackOverflow or I would still be stuck on it now. Check the link above for the given solution. Apart from that, and a few issues with my Apache server, it was a relatively smooth upgrade.

The most compelling and thought inspiring comparison I have read on the issue is in a book called The Big Switch. In his book, Nicholas Carr takes us through the electricity generation and the evolution from power generation to mass power distribution. In the 19th century, any business wishing to power their plant would need to purchase and run a personal electricity generator built using Edison’s dynamos. Thomas Edison realised late in the century that electricity could be outsourced to power plants, which were able to supply an entire block with life giving power.

Edison however, never saw beyond this and believed he could profit by manufacturing and distributing the components for his power plant dynamos. It took a man named Samuel Insull to realise the potential of electrical power distributed as a utility. He discovered that power could be created and distributed in large quantities much more efficiently and at a fraction of the cost of Edison’s Dynamos. In a very short time he was powering the majority of the businesses in Chicago from one huge power plant.
These companies had realised that by avoiding the purchase of expensive equipment, they were able to reduce their own fixed costs and not have to worry about maintenance or obsolescence. Electricity as a utility had triumphed over the private power plant.

Present-day, we can see the same process taking place in the computing industry. The personal computer era facilitated by Microsoft saw the rise of the Client-Server model of computing. Through office based data-centres, workers on personal computers are able to access the network, files, printers or other services. Although this model became hugely popular it also made the entire process massively inefficient.
This is largely due to the lack of industry standards, meaning that hardware and software companies constantly compete by selling products that do not interact well with their competitors versions. This results in machines dedicated to single purposes, such as databases or web-servers and in order to host a new application or service a company must purchase another machine to dedicate to it. Furthermore, in a stable system, these computers need the capability to reach peak demands, and their available resources must reflect this even if the peak is rarely reached.
My most recent employer was suffering from this in a bad way, a recent review estimating that under 40% of the total processing power was in use over 90% of the time.
In short, client-server computing has destroyed the conservation of energy and processing power that had been present in previous generations.

Obviously clear similarities can be made from this to the electricity era, the self contained data-centres businesses construct being just as wasteful and expensive as Edison’s private dynamos.
From this comparison it is easy to wonder why computing as a utility was not at the forefront of the computing generation. However, it had always been limited by a lack of sufficient bandwidth in the same way that electrical power was limited by DC. Now that network speeds are sky-rocketing and becoming cheaper, the power of computers can be delivered to users from a great distance, ushering in the age of utility computing.

From this description it’s difficult to see how Apple’s new service fits into the cloud computing model. By that I mean the fact that when using their iCloud service you get nothing more than online storage for your music. In order to listen you are still required to download your tracks to a physical device. Essentially they are providing outsourced storage, but hard drives are as cheap as they have ever been, and storage is now the most inexpensive part of computing. However, Microsoft and other manufacturers have also been following this same, seemingly unprofitable business model.

I believe it’s plain to see the future lies in outsourcing the whole deal, or more importantly, the processing element of a system. This is already happening, but we have obviously not crossed over to this model yet and due to current mind-sets I don’t think we are quite ready to leave the client-server model behind. This said, I don’t think it will be long before our home PC’s consist of barely more than a monitor, accessing the cloud for any service we require, we just need a large corporation to give the industry a shake. Google have already attempted proper cloud computing like this with their new OS and it has also been experimented with on a few other platforms.

However, large companies such as Apple and Microsoft are doing nothing to facilitate this jump. Personally I see these companies as the Edison of the digital world. They came up with a good idea, but are unwilling to push it onto the next logical step, and their concern with the potential obsolescence of their current products (such as Windows or iTunes) is holding the industry back and costing us all money.