I was hoping that there’d be some deep insight into the pros and cons of the Java web applications and the JSF framework and RESTful Web Services, but it was pretty clear that we weren’t going to cover enough ground to make the course worthwhile. There’s also some pretty idiosyncratic approaches to writing Java code going on too, so it was all a bit strange.

I could have carried on through the module as it should have been easy to get a good grade but then I’m doing the course for the challenge and opportunities to learn more than for the letters after my name. It’d be a shame to lose out on learning something else.

The software engineering modules have been a little disappointing, to be honest – where I found the Computer Science modules assumed a challenging knowledge of maths and computing, the software engineering modules seem to assume little or no prior knowledge. Maybe that’s just my perception, having been working on-and-off in software development for the past 4-5 years.

On the bright side, I did get a lead on what looks like an excellent book to get stuck into JSF 1.2 in Core JavaServer Faces by Geary and Horstmann.

That means that I just need to revise the Patterns for e-Business course foe this set of exams. In Autumn I’ll continue with Computer Science modules and it’ll be once more unto the breach with the whole logic thing, so I’ve pulled a couple of books out of the library to get started with that again.

I thought I’d find out a little more about some of the computing cornerstones that were laid in Manchester’s labs. Did you know that the first Random Access Memory was created there? Fast, random access memory is a core part of computer systems today. Having enough of it is crucial to making your laptop or desktop run all those applications quickly for you.

The Williams (or Williams-Kilburn) Tube was the first random access memory that could access at speeds suitable for a computer. It was the ancestor of the multi-gigabyte cards you’ll find in your computer today.

Back in the days before TVs were two inches thick, the moving pictures on the screen were drawn by magnetic fields and streams of electrons in a glass tube called a Cathode Ray Tube, or CRT. Did you ever hold your hand near the screen of a CRT television and feel the static tingle? Somewhere around 1946, Tom Kilburn and Freddie Williams at Manchester University used the charge on a CRT’s phosphorescent coating to store ones and zeroes (effectively as dots), where they could be detected by a ‘pickup plate’ which lay over the ’screen’.

As the electron beam hit the screen, a positive charge would be left behind at that position. Not for long mind you, as the charge would dissipate, but the information read by the pickup plate was used to refresh the tube before the charge had chance to leak away. This refreshing process is still required by the RAM chips in your computer today.

If you’re interested in knowing more, you can read all about it on Wikipedia and computer50.org, the sources I used to get this information.

To test the Williams Tube, the folks at Manchester built the first stored-program computer, a pretty important milestone in its own right. Maybe more on that some other time.

There are two notations for Business Processes put forward – BPMN and UML Use Case/Activity Diagrams. My part of the coursework assignment is to apply BPM to the johnlewis.com some processes on the website, for which I’ve chosen Activity Diagrams and Visual Paradigm for UML. I did take a look at the implementations of BPMN, but I found a familiar pattern – they either didn’t work or cost $$$. Fortunately, VP is still serving me well.

The lab session was spent working with my team on the coursework and setting up tasks for the rest of week. As we’re producing a large report and taking different sections, we’ve set up a Google Docs site to drop working drafts onto to help us collaborate. It’s the first time I’ve used Google Docs like this and so far I like it, it’s responsive, intuitive and it’s easy to share a folder with a group of people, so for this kind of work it’s looking good.

In other news, the marks for the Machine Learning module are in and I’m very happy to have passed! That’s two modules, or one-quarter of my MSc done.

I quite enjoyed having a simple pet problem like this, with a real reason to work through some aspects of it. If you’re interested in having a go yourself, the assignment reminded me of the first pragprog Code Kata – Supermarket Pricing.

As a result of the coursework, I’ve found a UML tool I can live with – Visual Paradigm. I’ll probably do a bit of a review and compare with the other tools I tried soon, but suffice to say it was by some margin the most pleasant and easy-to-use tool of the 5 or 6 I tried. £40 needed to get rid of the invasive watermark, but it looks like when it comes to CASE tools you get what you pay for.

The lectures are proving tricky to keep on top of – the pace is kinda slow (maybe that’s just me), so I find myself struggling to maintain attention. Still, the lecture notes are very detailed, so I spent a a few hours reviewing last week’s notes creating myself some revision material. I’ve been using a piece of software called Freemind to do ‘mind-mapping’, something I found out about in a presentation by Steve Brett in last years’ unsheffield unconference. It seems to work pretty well for the way I do revision, here’s a screenshot if you’ve not seen a mind map before.

So anyway, it’s all good. Coursework part 2 starts now, two more lectures in this module.

First up, the lectures were originally timetabled for a 9:30am start, and are now timetabled for 11:00am. That gives me loads of time between arriving in Manchester at 08:00 and starting lectures to eat, get to the library, do any admin stuff that’s easier when I’m onsite and generally chill out before getting started.

Second – I signed up for ‘IBM Patterns for e-Business Applications’, because I wanted to get some Software Engineering coverage as part of my MSc, and there was some coverage of design patterns in the syllabus for this module in 2009. I was in two minds about it, studying something with ‘IBM’ on it didn’t seem entirely right for an academic course.

To my surprise, the course has been re-branded ‘Pattern-Based Software Development’ overnight, and a complete re-write of the lectures has started to appear that appears to focus on understanding and applying some of the GoF design patterns – pretty much the exact course I wanted to take. I’ve studied and applied some of the GoF patterns before, and I’m really looking forward to learning the syllabus and having my work critically reviewed.

As an aside, it looks like the Manchester CS department is completely re-working its taught MSc Advanced Computer Science proposition, organising the taught modules into ‘pathways’ like Artificial Intelligence and Natural Language Processing. Looks like a good move to me, helpful for students choosing modules.

The lecture material introduced the Strategy, State, Proxy and Item Description patterns. The first three are pretty well known, but it’s the first time I’ve come across the last one.

Coursework material involves UML Class diagrams and designing a system to solve a loosely defined business problem. Unfortunately, it seems that good UML tools are tough to find. After a few days of battling working with the Eclipse project’s UML2 plugin I’ve come to the conclusion that I don’t much like it for simple diagramming. I’ve tried a few other tools with limited success, just a couple left to try. It might be you do have to pay $$$ to get a good one – but we’ll see.

My Top Tip for distance learning today has to be: if you have to attend classes, labs, exams – you know, stuff that you can’t really afford to miss, aim to be there an hour early.

Today, I didn’t realise that the exam wasn’t in the same building that I’ve had every lecture, lab and exam so far. In fact, it was on the other side of the campus, and it’s not a small University. I was very glad of having 45 minutes from checking my information to the exam starting! Totally my own fault, of course – focussed on studying and the date and time of the exam, I made an assumption – but these things happen. If you’re there early and everything works out fine you have time to relax and centre yourself. On the other hand, if there is a problem, you’ll be very glad of that time.

The course itself was a fascinating introduction to several aspects of automated learning. Starting out with linear and nonlinear classifiers, moving on to decision trees, then probabilistic classifiers, unsupervised learning and finally sequence learning, we covered a large set of knowledge with significant maths pre-requisites.

Most of the material was quite approachable (now that I’m largely over my irrational fear of mathematical symbols – I wonder if there’s an official phobia for that?), with the notable exception of the probabilistic stuff. I’m not sure why I had such a problem with it and even after some serious digging in books I’m still not totally clear on some of it. More work needed there in the future, I fear.

Funny thing about the maths stuff – it has taken/is taking me a lot of effort to penetrate the notation. Once I can read it, though, the concept hiding underneath tends to be fairly intuitive. Go figure.

So how did the exam go? As with the last one, I can easily imagine how it might have been much tougher. Feels like it went OK, but you never know do you?

Anyway, now the immediate study pressure is off for a few weeks I’m hoping to catch up on some reading (right now, a quarter of the way through Code Complete 2, by Steve McConnell – I’d like to finish that off) and get a few more blog posts in.

No, come back – some of this stuff is actually quite cool, I promise!

Here goes, in no particular order:

How to make $1M with Machine Learning and Netflix

Netfix offered a $1M prize for a team that could best their video classification technology by a significant margin.
The netflixprize page tells the official story, and the presentation attached to this blog post is well worth a look.

Detexify – Handwritten symbol recognition

For those of you that use LaTeX, you’ll know the pain of trying to find the code for a symbol if you can’t remember it. Detexify lets you draw a symbol on the screen, then uses machine learning techniques to recognise it and tell you which codes it thinks you need. The accuracy is astonishing – a really good showcase for the potential of the techniques.

Detexify in action

Lego Mindstorms Robots that Learn

This JavaWorld article takes Lego Mindstorms and adds a pinch of Machine Learning to make a robot that learns to follow a path on the ground.

I highly recommend this article for a casual read, it’s very nicely written and accessible but does delve into the theory and mathematical foundations of the Perceptron algorithm at the heart of the article.

Machine Learning at videolectures.net

There are 794 presentations and lectures – that’s not a typo, seven hundred and ninety-four – on every aspect of machine learning you could dream of here, at videolectures.net, from a range of sources. Many are quite approachable for the layperson.

The Singularity Summit

To wrap up, the Singularity Summit seems to be the forum for the players in the general Artificial Intelligence arena to talk about the past, future and philosophical implications of AI.

The Conversations Network hosts a free podcast series for the summit – personally, I really enjoyed James Hughes’ twenty-odd minute talk, in which he answers one of  the great unanswered questions – if you’re standing on a railway bridge, are you safer stood next to an artificial intelligence or a human being?

That’s All Folks

I hope there’s something in there that’s given you some food for thought. If you have any stuff that you think is awesomely cool in this space, drop me a comment so I can check it out!

Yep, those are just links to the Wikipedia articles, and it’s quite possible that if you clicked on them and you’re anything like me, the crazy-looking maths stuff at the other end made the sensible part of your brain run off and sit in a corner, clutching its knees and rocking gently back and forth.

Probably muttering to itself.

To be honest, I can’t really explain what this stuff is about just yet – I’ve had a lot crammed into my head over the past few weeks, and I think I need a really good night’s sleep before I can comprehend the deeper aspects of this last bit. Suffice to say for now that it seems like some really interesting and powerful ideas are in play, and when I’ve got my head round it I’ll blog up my thoughts.

I’ve now got one more homework assignment on today’s material to complete by next Wednesday, and the project we’ve been assigned to do is then due on Friday 6th November – a nice surprise, as a typo on the schedule had us believe it was due on the previous Tuesday.

I’m sorry the taught part of the course is done, to be honest. Although I’m not sure I could have taken any more at the pace it was being taught, I’ve thoroughly enjoyed the material.

In fact, I’d say I feel a little inspired.

And, as James Brown might say – it feels good.

The last section involved performing a computation over a data set that took a few seconds per run to exhaustively search for the optimal settings for two parameters in the computation’s algorithm. Searching over 25 possible settings doesn’t sound like a lot, but two of ‘em means 625 runs – times a few seconds is quite a wait.

Oh, wait – there was also a requirement to randomly shuffle the input data for the algorithm ten times and do some simple stats, to give some chance of reducing potential bias brought about by the order in which the data appears in the data set. So that’d be 10 runs per pair of parameter settings, which is 6250 runs. Or several hours with a CPU core maxed out and a nice, toasty computer.

But hey. I got some neat 3-d mesh plots out of it, showing the performance of the algorithm over the parameter search space. Proper science, this! Sure it has faults, but Matlab’s plotting functionality is pretty neat and easy to use. Plots like the following are a doddle:

Figure 1. Gratuitous use of a 3D plot for fun and profit

The goal of the exercise was to identify the most relevant ‘features’ in the data set for assigning the data into an appropriate class. Imagine you had a big table of information about a set of people, where the first column (could call it ‘Feature 1′)  was their heights, the second was the time of day the height was measured, and you were trying to predict their sex. You and I would guess that height would be a good indicator of sex and the time of day would be irrelevant, but we’d be cheating by applying information about the meaning of the data that exists in our heads and wasn’t supplied with the problem.

By applying a variety methods to our table of data, a computer might be able to recognise relationships between the features and what we’re trying to predict, without knowing anything else about the information. In doing, it could remove the features that do not appear to have any relationship and save the computational effort and time that would otherwise be spent processing useless data. The approaches that can be applied are various, and some degree of tuning needs to be applied to to ensure that removing features doesn’t compromise the goal in subtle ways.

Today’s lectures moved on to machine learning techniques using the perplexing mathematics of probability (perplexing for my tiny brain, at any rate), in preparation for the last two weeks where unsupervised learning is the order of the day. The usual lab afternoon was focussed on kicking off a three week project involving applying the techniques we’re learning to do something with bunch of data in the style of a research paper.

Time to polish up the LaTeX from last year then…

I think I defeated the XQuery assignment. It took the best part of a week, guessing at around 18 hours,  but my 485 lines of code handle everything I can think of that was within the spec of the assignment. It was loads of fun handling transformations from various combinations of sequences, choices, star-expressions, minOccurs and maxOccurs in an element to a XML description of regular expressions, as well as implementing a combinations generator and a function to filter out unique elements in a sequence of elements.

I’m sure all that stuff with a functional lean is pretty old hat to someone who’s a Python, Erlang, F# or Haskell guru, but for little ol’ me with my OO background, it was pretty painful to swap my thinking over to immutable variables (which I’m sure is a contradiction in terms!), a complete inability to track state and just plain indulgence in recursion.

In short, it was brilliant. Exactly what I’m here for, to get out of my ‘comfort zone’ and learn new ways of thinking.

Transforming XML documents using XSLT seems to be a bit of a breeze. I have used XSLT before the course and I generally like it for doing transformations. It has a flexible template-based structure which makes reuse quite attractive and works in quite a straightforward way, once you’ve got the idea behind it. As a friend commented over lunch the other day, it’s a very declarative way of doing things. If you try and write procedural code in XSLT, you’ll probably have a hard time of it. As will the next guy, who has to maintain your templates.

The manual run of a tree against a tree grammar was a little painful. There were some tedious aspects to it, but it did show up a couple of things in the algorithm that I hadn’t quite understood properly, so it was a very worthwhile exercise.

Still no sign of any marks for any of the assessments, and things went kind of quiet on the email and discussion forums front too. Turns out to be due to the issues with the Blackboard product I mentioned in the last post, and illness in the teaching staff. In fairness, the deadlines have been slightly extended further to compensate. I’m told we’ll get some marks back later today…

…and that’s the end of my first MSc module’s taught component. Now, there is a big gap, barring the exam for this module in May, before the next year begins in October…