M301 Software Systems & Their Development (2004)

Level 3, 60 points.

For my first few years with the OU I heard M301 mentioned in hushed tones. It was the Course Of Doom, the point at which Ye Who Entered would be well advised to abandon hope. By all accounts this was a very difficult course. It also happened to be one of the key courses on the way towards my degree. The course description advised that the proper preparation for the course would be a good result in M206. Well, I had a good result in M206 and the statistics published annually by the OU showed that there was a fair dropout rate but nothing excessive, and a reasonable pass rate for those who completed the course. So I signed up and braced myself...

Block 1: Introduction to Java

I heard it said by a number of people, including tutors, that M301 did not teach Java, but you would need to learn Java in order to get through the course, and that seems a fair assessment to me. This block, with the aid of a rather dull and clompy textbook, Object Oriented Programming with Java (Budd 2002), gave a rapid run through the basics of Java. I am glad that I spent some time before the start of the course learning some Java off my own back, as the information and exercises provided didn't dwell for long on the details.

Blocks 2 and 3: Concurrency

If the set book used in block 1 was poor, the course's other one, Concurrent Systems (Bacon, 2003) was far worse. I don't like to dwell on this, but feel I have to as it was such an important part of the course. Despite this being a third edition of the book, apparently heavily revised with the help of the M301 course team, I (and just about everyone I spoke with, including tutors) found it stodgy, over-wordy, badly explained, poorly laid out and more of a hindrance than a help to understanding what is already a complicated subject matter. Luckily, I had found another, far older book (Concurrent Programming (Burns & Davies, 1993)) covering roughly the same subject matter which explained many of the concepts in what I found to be an easier matter, using half the page count.

The subject matter here, concurrency, is probably the most difficult that I have encountered in the OU. Modern computers can, and generally do, do many things at once, but there are many inherent problems involved where different processes interact and, in a nutshell, these two blocks cover various ways to get the advantages of interacting concurrent processes while avoiding the many pitfalls. I loved all this stuff, but did I mention that the textbook was awful?

Blocks 4 and 5: Object Oriented Software Development

These blocks went over a lot of the analysis and design ground covered in M206, but in much greater detail and making use of a large proportion of the gory details of UML, the Unified Modeling Language, which offers many different ways to show pretty much the same thing depending on what you are trying to emphasise. There was also quite a lot on other issues like code generation tools, patterns, quality and project management, and human factors. Quite a lot of block 5 in particular covered "professional issues", which is actually important stuff to know for anyone wanting a career in software development. Or anything else project based, for that matter as many of the issues are pretty generic.

I found a lot of management and professional skills work very tricky in comparison with the more technical elements earlier in the course. This isn't really because this is the most difficult section, but rather because my previous experience hadn't really prepared me for it. I can't say I really enjoyed this subject matter, but I feel it was useful and that I learned a lot from it.

Block 6: Integration

The final block throws in a couple of additional topics: security, including a brief primer on cryptography, and legal and ethical issues (including an advertisement for the British Computer Society). This is all quite interesting, though I found the cryptography sections to be rather lightweight, though that is probably because I have already read on the subject. As in other courses, the last block just seems like a pile of other issues, but this time these issues fit a little better with the general flow.


This is indeed a difficult course with some tricky technical concepts in the section on concurrency and some big ideas in quality and project management. It pulls together a lot of concepts, not always smoothly, but provides part of a powerful backbone education for students with an interest in software. This, I think, was a great achievement and probably yielded my greatest celebrations when I received my results.

This page last modified: 2005-10-27.