Coursework…Coursework…Coursework

There are, in my experience, two types of coursework. The first type is the one actually set by lecturers, which you hand in and get marked. Sometimes this coursework actually counts towards your degree, sometimes not. More often in Computer Science, the coursework counts for about 10% of the final grade, which I think is a ridiculous amount considering the amount of coding that goes into them. The second type of coursework is the one that isn’t specifically set by the lecturer, but which they hint at and make you think “holy shit, I’d better actually do try this out”.

Recently I’ve been doing a bit of both, and so I now present to you, second year “coursework” for Computer Science:

Robotics

Possibly my favourite part of the course is when I get to mess around for hours in labs with Lego NXT robots. Last year we had to get them to do simple things like collision detection (making them run around the room without banging into anything), but this year we are expanding into the realms of sensor calibration and maze-solving. Our current team robot is the most compact we’ve built so far,with a footprint of 130mm x 120mm. The maze walls are very low, so all three sensors had to be very low down on the robot, and the two wheels at the front are as close together as we can possibly get them. We went through several different methods when creating the rear pivot, first using a flywheel, then a small ball, before finally using a flexible prong that both supports the robot and gives it much needed suspension. The final robot looks like this:

Our robot, affectionately named "Cockmuncher"

The robot currently solves mazes using the Left Hand Rule, and will soon use Tremaux’s algorithm and the ever popular A*.

Algorithms & Complexity

“Algorithms: Yay! Complexity: Boo!” is how I sum up this course, because although we learn about the implementation of a load of useful algorithms for sorting and searching, we also learn about their complexity and the horrible calculations you have to do to find them. Eurgh.

Nevertheless, I decided it would be fun to program some of these algorithms in Java. I used a custom made random number generator to produce various files containing comma-separated unsorted random numbers. I then used various sorting algorithms to sort the numbers into numerical order. So far I’ve coded versions of Bubble Sort, Merge Sort 0, Insertion Sort, and Heap Sort. Once I’ve got the programs to a workable condition I’ll release the source code online for people to play about with. I also need to code Quick Sort and a few searching algorithms.

Update: Here is a screenshot of my implementation of Heap Sort, sorting a random array of 1,000,000 integers:

6.60 seconds...bitches.

Until I implement Quick Sort nothing else has even come close to beating (or indeed actually finishing within 10 minutes) Heap Sort in this test. It is legendary :D

Information Security

For my specialisation, I’m doing Information Security, which involves lots of cryptography (code breaking), and looking into security of systems. Currently we’re going through keystreams and hashing functions, and we’ll be programming implementations of those next term.

For now however, I need to get on with my work! :D