I've been doing some mulling and wanted to post something, partly to get ideas straight in my head, and partly to try to let people know how I (and at least some of my colleagues) feel about some of the issues around delivering modules to students in university. So here goes...
Teaching is mainly quite fun and hard work, but is not quite as simple as it may seem. Learning should also be mainly quite fun and hard work, but it is also not quite as simple as it seems. Particularly in a university context. Teaching my kids to ride a bike is an example of a kind of teaching that is very easy for both the teacher and the learner to appreciate: you know when you've got it wrong (it hurts) and you know when you've got it right (because it doesn't hurt). Riding a bike is a difficult to master but simple skill. You will often encounter very similar conditions in which you ride a bike. You may choose to ride your bike around Nant-yr-Arian or up and down steep hills, but you will be deploying the same basic principles many times over. You may need a few new ones to deal with new situations, but you are essentially building on a core principle and honing your abilities.
Unfortunately teaching and learning at university is nothing like that. Writing computer programs to implement software systems uses a set of skills that you could choose to view in this way. You will use variables, parameters, functions, loops, if statements etc... each time you write a program (assuming you're using Java or C or something similar), and you could argue that this is analagous to riding a bike. However when you build a significant piece of software this is a tiny part of the problem. You also need to understand the domain of the problem, any other systems or libraries that you need to use, how to structure a sensible solution, the time and space constraints and characteristics of your system and a whole load of other things. If you get any of these conceptually unrelated things wrong then your system is likely to fail completely. It's very difficult to "go slowly" or "get off and walk" as you would on a bike.
But it's more different than that.
The idea of studying computer science at university is not to teach you to write good programs in Java or C++ (or whatever). This should not be a surprise, but I fear that it will be for many students. The idea of studying computer science at university is to develop a sufficiently good understanding of the fundamental issues of computer science that you can understand, analyse, predict the behaviour of and create computer systems in a wide variety of settings and applications. The idea is to equip you with the intellectual tools to allow you to tackle a wide range of problems in computing. The precise set of intellectual tools that we aim to provide depends on what degree scheme you are on. A happy outcome of acquiring this set of intellectual tools happens to be that it will make it possible for you to relatively easily learn any of the huge variety of programming languages that are out there and to write good programs in them.
The process of trying to help students to acquire a set of intellectual tools appropriate for any discipline, whether it be history, French, philosophy or whatever, is fraught with many dangers and difficulties. Computer science is particularly fraught because it is such a young university subject: no-one can really agree on much about how it should be taught or even what the essential intellectual skills are. Whilst philosophers are an argumentative bunch, I suspect that most of them would be able to agree that there are some really fundamental ideas at the heart of their topic and some really well rehearsed arguments about them that any philosophy student should study, maybe something like the nature of knowledge (epistemology) would be considered to be one of these fundamentals. Computer scientists can't even agree on whether or not, and certainly not how, we should teach programming (yes there have been very good computer science courses that didn't teach programming).
So whether you like it or not, computer science students are guinea pigs. Philosophers have had a few thousand years to figure out where some of their priorities lie, maybe in a few hundred years we'll have some better understanding of what computer science is all about.
In the meantime we are trying to teach people using whatever ideas and tricks that we can. For example in my ubiquitous computing module I regularly set an impossible problem in order to get people to think through possible technical solutions to parts of the problem. Not because I expect them to solve it, but because I want them to think through a difficult problem in a scenario with which they are not familiar. I want them to got through the process of assessing which parts of it they think they can tackle, and to use the intellectual tools they have acquired in this module and all the other modules that they may have sat to create potential solutions to parts of the problem. For me this process of understanding an application area outside computer science and developing sufficient understanding of it such that you can create solutions in that area is at the heart of ubiquitous computing. That is one of the "tools" (probably the most generic one) that I would like people to take away from this module: the idea that you have to study and think about the scenario which you are tackling in order to produce effective solutions. I don't really care about what the particular scenario is, but I do care that people go through the process of understanding it, thinking about it and finding technical solutions that fit into it. Because that is the kind of skill that will be useful for them in this area in future.
This is where the difficult learning bit comes in. Unfortunately you have to trust us when we tell you that this stuff is "good for you". Even if you don't believe the rationale that we give you for trying to solve an impossible task. It really does seem to work. Honestly it does. But it does involve some seriously hard work to do this sort of thing, both in terms of reading, thinking and investigating, but also in looking beyond your immediate boundaries. Having said that, we have only had a few decades to try to get computer science teaching to work, and in the case of something like ubiquitous computing even less. We (at least I) do get things wrong, but I really do believe that we need to concentrate on things that are more fundamental than just how to write good Java or C++. I think teaching you to write good Java or C++ can be a useful exercise, but trying to help you keep your eye on the bigger issues is also very important, and I for one will keep trying to help students to think beyond the obvious and immediate. I also think that that is what good employers want. If they want you to write Java or C++ then so be it, but they will also want you to be well-informed enough to understand the pros and cons of various approaches and to be able to understand and work with experts in other fields.
In short, I think that you do need to "get your head down" and tackle the tasks you are set, but that the really useful learning is in the time after you have done the assignment or sat the exam when you sit back and think "Ah, so that was what that was all about!".