Description and Reflection

Background to computer-algebra teaching at Queen Mary

In the mid 1980s, a colleague (Malcolm MacCallum) and I developed similar interests in computer algebra at about the same time and concluded that we should introduce an undergraduate module on computer algebra. We designed the module to consist of three sections: using computer algebra in practice; how computer algebra systems work; some mathematical background to computer algebra algorithms. We decided to focus on the REDUCE computer algebra system because Malcolm and I had experience of REDUCE and it was at the time the cheapest system and the one that had the smallest resource requirements. We saw this module as a specialist module that might appeal to a small number of students with interests in both mathematics and computing. The mathematics underlying the algorithms is advanced, so we aimed the module at our final year undergraduates. I believe that we were one of the first universities to offer a course in computer algebra.

Providing computing facilities for the practical work was a challenge because by the standards of the time computer algebra required a lot of computing power. (In particular, it requires a lot of RAM because computer algebra requires genuinely random access to large data structures. This is not well supported by virtual memory, which swaps data between RAM and disk storage.) Consequently it was not feasible to have a lot of students running REDUCE on a multi-access computer. At about this time, the BBC micro computer became available and Queen Mary decided to use them for teaching. I also had one in my office. The BBC micro was capable of running REDUCE provided it was equipped with some extra RAM, which it was possible to buy from an independent supplier and connect with the aid of a soldering iron as an after-sales modification. We persuaded IT Services to buy and install extra RAM for about a dozen of the BBC micros used for teaching. In this way, we were able to support computer algebra practical laboratory sessions.

We subsequently introduced an MSc course in mathematical computing for which I was the programme director and which included some computer algebra similar to what we offered in our undergraduate module, but to support the practical computing for the MSc course we had a small dedicated laboratory in the Mathematical Sciences Building consisting of about a dozen Atari ST computers. The Atari ST was also capable of running REDUCE, courtesy of the same small Cambridge-based software house that provided REDUCE for the BBC micro. If I recall correctly, we were able to buy Atari STs with enough RAM to run REDUCE adequately, although it ran better with more RAM. I added some extra RAM to my personal Atari ST, which I used to write my first (co-authored) textbook in 1991 called Algebraic Computing with REDUCE jointly with Malcolm MacCallum. We alluded to some of the background described above in the preface.

Malcolm also experimented with using REDUCE as an optional adjunct to support a first-year calculus course, but this was not really successful because instead of helping students to understand the mathematics, most students saw the use of REDUCE as additional work and, since it was optional, avoided it. Nevertheless, I learnt a lot from Malcolm's initiative and it helped to inform our next development. We dropped our third-year module around 1990 because such a specialist module had to be optional and the number of students taking it became too small to make it viable.

By the early 1990s, computer algebra systems had evolved into mathematical computing systems that included good facilities for numerical computation and graphics. The most widely used systems were (and still are) Maple and Mathematica, which both had user-friendly graphical user interfaces when run on suitable computing platforms. These included the Apple Macintosh, which by this time was well established and was popular with academic staff, and Microsoft Windows, which had evolved to Windows 3.1 – the first widely used version of Windows. Queen Mary had recently established new computer-teaching laboratories equipped with networked personal computers running Windows, which were capable of running Maple and Mathematica.

In 1993, the School of Mathematical Sciences decided to replace its first-year computing module based on FORTRAN with a pair of new modules based on a mathematical computing system. I was part of the team that developed this pair of new modules. The problem with FORTRAN is that, being a compiled language, it is typically necessary to run through several iterations of the edit-compile-debug cycle before being able to execute a program. I learnt from my own and colleagues' experiences of teaching with FORTRAN that if the aim is to illustrate some mathematical topic then students can get lost in the computational convolutions and miss the point, much as happened with Malcolm's experiment using REDUCE for first-year teaching.

Computer algebra systems, such as REDUCE, Maple and Mathematica, can all be used interactively, which makes program development much faster and more direct. They also support much higher-level mathematics directly: algebraic manipulation, differentiation, integration, etc. We felt that use of such a system would really assist our students to learn first-year university mathematics without just becoming an additional educational burden. (However, I have learnt from teaching with computer algebra systems that it's a moot point whether this is true. I think it's true for engaged, computer-literate students, but not for all students, especially the generally weaker students, who of course are precisely the students one would like to support.)

We chose to use Maple for the new pair of modules because it was cheaper than Mathematica and had a more student-friendly user interface than REDUCE. Maple was developed (in the 1980s) primarily for teaching, which meant that it did not require huge computing resources and it provided many of the facilities that students might need, such as relatively trivial functions that other systems did not include, presumably on the grounds that an expert could write them in a few minutes. Some of us also had (and still have) some reservations about Mathematica. Its syntax is idiosyncratic: for example, the trigonometric sine function is written as Sin[x], with a capital letter and square brackets, whereas almost every other programming language uses sin(x), which is essentially the same syntax as used in conventional mathematics. This was important because our goal was to teach the basics of computer programming in general and using an unduly idiosyncratic language would not facilitate this goal.

We have used Maple as our primary teaching language since the early 1990s but concern is mounting now that it is not sufficiently vocational. We are under growing pressure to improve our undergraduates' employability by making our teaching more directly relevant to careers. For next academic year, we have introduced a new first-year computing module based on Microsoft Excel, initially to support new degree programmes in mathematical finance. It is being suggested increasingly often that we should replace Maple in our second-year module on numerical computing with MATLAB, which is far more widely used in industry and commerce than is Maple. This makes sense except that students will have to learn another system, having learnt Maple in their first year. However, given the extent to which students forget what they have learnt from one year to the next, perhaps learning MATLAB is no worse than re-learning Maple!

We designed the pair of new Maple-based module in 1993 so that the first-semester module would involve primarily "one line" use of Maple to solve problems that students were meeting in another first-year module on discrete mathematics and the second-semester module would introduce computer programming to solve more intricate problems. I developed this second-semester module and taught it until 2003. It was the basis for my second (solo) textbook in 2001. We then decided we needed to compress our first-year computing into a single module, so I designed a new syllabus to achieve that with significantly less focus on programming. (I was asked to do this because at the time I was director of our joint programme in BSc Mathematics and Computing, which we no longer offer.) Much later, I was asked to take over the teaching of this module from September 2012. I have taught it for the past four years and I expect to teach it again next year for the last time.

My current module: Introduction to Mathematical Computing

When I was asked to take this module over in 2012, I made three major decisions:

1. Queen Mary was in the process of moving from Blackboard to QMplus (Moodle) as its VLE, so rather than set up a site on the Mathematical Sciences web server and then move it to QMplus the following year, I decided to use QMplus immediately, making me one of a handful of early adopters within the School. This was definitely a good idea.
2. The School had decided to introduce a new first-semester module called Mathematical Structures that aimed to help bridge the gap between school and university pure mathematics, which was taught for the first time in the autumn of 2012, in the same semester when I taught Introduction to Mathematical Computing for the first time. I decided to tie my module in with Mathematical Structures as closely as possible by discussing some of the key topics about a week after they were introduced in Mathematical Structures.

   This tie-in works, but not as well as I had hoped. Students are nowhere near as good at transferring information between modules as I and my colleagues would like them to be, so when I thought I was building on ideas the students had already assimilated, many of my students reacted as though I was teaching them new mathematics. A potential disadvantage of tying one module closely to another is that if the syllabus of one changes then the syllabus of the other also has to be changed, and simply changing the order of material taught in Mathematical Structures could require significant revision of Introduction to Mathematical Computing. This hasn't actually happened, but it was considered a year or so ago, and I had to point out that it would have a major knock-on effect on me. Fortunately, I don't think the Mathematical Structures module organiser was any more enthusiastic about making significant changes to his module than I was!

3. Over the previous 10 years or so, Maple had acquired a new graphical user interface (GUI), called the standard interface. This is implemented in Java rather than C and is common to all supported platforms. Initially, this new GUI was somewhat clunky, but by around 2010 it had become the GUI I used for preference. It offers much better support for mathematical notation than did its predecessors on any platform, in particular "math mode input" that makes user input look like the same typeset mathematics that is (normally) used for output. (High quality mathematical output had been available for a long time, but using the same display for input was new.) I decided to use the standard interface and moreover to focus on using math mode input, whereas colleagues teaching Maple-based modules have so far all stayed as close as possible to a conventional command-line interface.

   Using math mode input also works, but not as well as I had hoped. Whilst it is possible to make Maple input look very much like textbook mathematics, there are two disadvantages. One is that students tend to assume that arbitrary mathematical notation is acceptable to Maple as input, which it isn't. For example, the following is a meaningful mathematical statement: "Suppose that A is a set of numbers and let B = { 2a : a ∈ A }." It is possible to input B = { 2a : a ∈ A } as Maple input in math mode and it will look exactly as shown, but attempting to execute it will fail. The appropriate Maple input would be B := { seq( 2a, a ∈ A ) }, which is very similar but has some crucial differences (highlighted). The similarity between mathematical notation and Maple input that I see as an advantage, students may see as a source of confusion. The other disadvantage of math mode input is that it involves hidden formatting characters that students manage to mangle so that their input looks superficially correct but doesn't work. On balance, I don't think that using math mode input causes any more problems than using conventional text mode input, it just causes different problems.

In order to accommodate decisions 2 and 3 above, I wrote a completely new set of lecture notes and I wrote them entirely using Maple. I released these notes to my students on a weekly basis just before the week when I would cover the material. I divided each week's notes into three lectures, so that each week's material was fully mapped out in advance. I wrote detailed notes so that students should be able to answer any questions they might have for themselves by reading the notes. There were typically 4 or 5 typeset pages per lecture. I also provided weekly exercises consisting of typically two starred questions that I asked students to answer and submit for feedback (formative assessment) plus a handful of other questions. After the submission deadline each week, I released my model answers to all the questions, which gave students a lot of examples to study. I used QMplus to distribute all my teaching materials and my students uploaded their exercise answers to a QMplus assignment activity each week.

I have four PhD students to provide the feedback on my assessed exercises and I use the group facilities in QMplus to allocate students to markers. Moodle provides a facility to allocate students to groups automatically, which would have been ideal, except that it did not work properly in QMplus. There was no way to restrict the enrolled users who were allocated to groups to be only students, so I had to revise or generate the allocation of students to groups by hand. (This problem with QMplus was fixed very recently.) I also have a number of teaching assistants (TAs) in the computing lab classes that support this module, who initially included the PhD student markers and later were only the PhD student markers. I provide them with full solutions at the same time as I release the lecture notes. I use the facilities for timed release of resources in QMplus and I enrol my TAs as (currently) non-editing teachers so that they can access teaching materials that are still hidden from students.

Because I learnt from my TAs that they did not all have convenient access to Maple I provided them with PDF versions of all my teaching materials. I found that students were asking me for copies of my teaching materials that they could read without access to Maple, so I started to release PDF versions also to students. But I want my students to focus on using Maple, so I delay the release of the PDF versions of my teaching materials to students.

The summative assessment for this module consists of a mid-term test contributing 10% and an end-of-year exam contributing 90%. From around 2010, the external examiner for our computing modules began to recommend that the summative assessment should be done using Maple, whereas up to this time we had always used conventional written exams and tests in which we asked the students to write down what they would need to type into the computer. This was partly because we did not feel that the computing facilities available were sufficiently reliable for summative assessment and partly because we did not have any computing labs big enough to accommodate all the students taking our larger computing modules. (I have around 200 students per year taking my module.) Nevertheless, I was fairly enthusiastic to try computer-based summative assessment.

In my role as Director of Undergraduate Studies, I encouraged the colleague who taught our second-year module Introduction to Numerical Computing to change to computer-based summative assessment because that module is a lot smaller. I arranged meetings with the exams team and with IT Services and obtained agreement, with some caveats, that we could try this. I learnt a lot about running Maple-based exams from this colleague. By the time I took over Introduction to Mathematical Computing, we had used computer-based summative assessment for Introduction to Numerical Computing for one or two years with an acceptable level of success. Therefore, I used computer-based summative assessment from the time I took over Introduction to Mathematical Computing and I organised it in the same way as my weekly exercises. Hence, I was able to teach almost entirely paper-free, thereby contributing to Queen Mary's green credentials!

I also followed the lead of my colleague teaching Introduction to Numerical Computing and made all my summative assessment open-book, meaning that students can access anything they want on paper or on the internet (except email, chat, etc.). For modules for which it makes sense, such as computing and other practical modules, I think open-book assessment has huge advantages: the environment is similar to a real working environment; it assesses understanding rather than memory; I believe that students suffer a lot less anxiety; there is much less scope for cheating so open-book assessments are much easier to invigilate. Generally, I am an exponent of open-book assessment, although I accept that it is not feasible for some modules, such as pure mathematics modules that require students to be able to state and prove standard theorems.

I also initially adopted the same approach as my colleague and used a single Maple document for my summative assessments that contained both the questions and space for the answers. However, I learnt that students could copy and paste information from the question to the answer. If I wanted to assess whether my students could input some mathematical expression into Maple I could not simply display the expression in the question. Initially, I tried describing in words what the expression should represent, but this is somewhat convoluted and unnatural. It is also potentially unfair to foreign students, dyslexic students, etc.

More recently I have switched to providing the questions in a PDF document (generated from a Maple original that I do not release) and I ask students to answer the questions in a Maple answer template document. This arrangement is also more flexible because students can tile the question and answer documents on their screens if they want. (The computers on the teaching network have large screens.) For the final exam (but not the mid-term test) I now also provide the questions on paper, which is consistent with the way we run most of our exams and keeps everyone involved in processing exam papers happy. It also gives my students even more flexibility since I still provide the exam paper as a PDF document via QMplus. But, unfortunately, my module is now marginally less environmentally friendly!

I take advantage of the fact that I use a computer algebra system for my summative assessments by arranging for Maple to do all the mark processing semi-automatically. I include a table towards the top of the answer template where I ask each student to provide their name and student identifier and in the bottom row of this table I enter their total mark for the exam. I also include a table after each question in which I enter the mark for that question and possibly some comments, which are primarily in case I need to justify my marking. The mark cell contains an input template that assigns the mark to a Maple variable of the form _Qn, where n is the question number. I normally let Maple add the contributions from sub-questions, so a typical mark assignment might look like _Q1 := 2 + 0 + 5 = 7 after I have executed the input. (Maple does the addition.) This sum provides an indication of how the mark is made up.

After I have marked all the questions, I evaluate the expression `+`(_Q || (1 .. 8)) in the main table, which adds the marks for all the questions to produce an exam total. If I have missed a question then its mark appears symbolically in the form _Qn, which is very easy to spot. This system reduces significantly the scope for errors in the mark arithmetic. When I have marked all the scripts, I run a Maple program that I wrote, which reads the student's name, identifier and total mark from each answer file and writes the data to a CSV file that I can then easily process further using other software such as Excel. (Maple provides facilities that can parse a Maple document file, which is formatted as XML together with some proprietary encoding of Maple input and output.) My semi-automated approach to mark processing requires very little independent checking and moreover checking is easy because my answer template has a fairly rigid structure and the marks are all in fixed places, rather than scattered randomly as arbitrary text, which can be very hard to find and add manually.

Our largest computing lab has a capacity of 100, but we always need to assume around 5% of the computers will be faulty. To accommodate my 200 students I run my mid-term test in two sessions, one after the other, with slightly different versions of the questions. The two versions need to be sufficiently similar that they have the same level of difficulty and I make them different mainly to give me some indication if a student has managed to cheat, which so far none has. Provided there is around 5% non-attendance, this works. My final exam is now timetabled in three different computing labs at the same time, which has the disadvantage that I can't attend them all.

There are always some technical problems, which I believe are caused by the Queen Mary teaching network being somewhat slow and unreliable. The teaching computers all run essentially as if they have no local disc drives, which means they load almost everything over the network. Sometimes it is impossible to log in on some computers for no obvious reason. If this were to happen a lot at the start of an exam it would be a disaster! The application software uses a virtualization technology called Thinstall, which does not appear to support Maple very well. It used to be the case that the Maple help facility ran so slowly as to be effectively unusable. It meant that the computer would just stop responding for a long time, which is not what students want to happen in an exam. Maplesoft redesigned the help facility a couple of years ago and now it seems to be usable on the Queen Mary teaching network, but we still recommend students not to use it and to use the Maple help available via the web instead.

Maple uses a client-server architecture and a problem that seems to have become more serious over the last couple of years is that it suffers "kernel connection errors" very easily. This means that the client application (the user interface) has lost its connection to the server application. Fortunately, this problem can be solved easily by closing Maple and opening a new instance, but it is disconcerting for students and wastes time they cannot afford in an exam. Another problem is that Thinstall caches some information in the user's file space, which can all too easily become corrupted. This can have very strange consequences, such as Maple not being able to save files. I learnt from our IT support staff that this problem can be solved by deleting the Thinstall cache and then opening Maple, which forces Thinstall to restore its cache. This fix is slightly tricky. I can do it in a couple minutes but it takes students a lot longer, even though I have been publishing the instructions ever since I learnt the fix. My colleagues always request some spare computer logins and use those for students who have problems, but then the students cannot access their normal filestore, which is unfair, so I prefer to try to fix the underlying problem for students. (But I also ensure I have a few spare logins and I check beforehand that they work!)

Evidence

My two textbooks on computer algebra arose from my historical involvement in our computer-algebra teaching:

• Algebraic Computing with REDUCE, Malcolm A. H. MacCallum and Francis J. Wright, Oxford University Press, 1991;
• Computing with Maple, Francis Wright, Chapman and Hall/CRC, 2001.

The following are alternative versions of the QMplus site for my current module, which illustrate my general approach to teaching, learning and assessment processes:

• The latest live version of MTH4105 - Introduction to Mathematical Computing should normally be publicly accessible (but may become less relevant after 2016–17 when I will cease teaching this module).
• This archive of a snapshot taken on 9 May 2016 should be accessible in a range of web browsers: it works for me using Edge, Internet Explorer, Chrome and Firefox on Windows 10. Download the zip file here, unzip it and open the file "Course  MTH4105 - Introduction to Mathematical Computing - 2015_16.html". (Note that the folder "Course  MTH4105 - Introduction to Mathematical Computing - 2015_16_files" must be in the same folder as the HTML file.) This snapshot is intended only to illustrate the current top-level structure of my module page; resources referenced in this web page either may not be accessible or may be later versions that are not entirely relevant.

This scan of my last peer observation summarizes a colleague's view of my current teaching. (I optimized and de-skewed this PDF file, which has made the lines defining the form slightly jagged.)

Here is an example of my Maple exam answer template exported to PDF, which shows the main student information table towards the top and the marking table for one question. Normally, all sections would be expanded except for the per-question marking tables, but for this illustration I have collapsed the answer sections for all except the first question and expanded its marking table.

Description and Reflection

The first year I taught Introduction to Mathematical Computing, in 2012–13, I taught it as a fairly conventional lecture module, except that I used Maple interactively to illustrate what I said as I explained the material. I assumed that students would read my published notes before, during and/or after each lecture and that there was no particular need for students to write conventional lecture notes. I noticed that attendance at lectures dropped progressively. The results of my module evaluation were not good (around 30% overall quality index) and I learnt from my students' comments that they found it unhelpful to watch a computer demonstration for an hour; they wanted to follow what I was showing on a computer for themselves. However, my experience of running (and attending) computer-based classes is that different students work at very different rates. I took the view that if I literally tried to have students work along with me I would rapidly lose most of them, so instead I decided to make the teaching entirely student paced for the second year that I taught the module.

I therefore decided to try to teach the module entirely in a computing lab with some teaching assistants available all the time. In the first year I taught the module, each student had three hours of lectures and one hour of computing lab per week. Given that I had to run two computing labs to accommodate approximately 200 students in our largest computing lab with a nominal capacity of 100, I personally had 5 contact hours per week. I assessed the amount of teaching support I had and decided that if I spread it a little more thinly I could give every student 3 hours of computing lab. I proposed to split my students into 2 groups, A and B, and give each group a two-hour computing lab as a replacement for three hours of lectures plus a one-hour computing lab as a continuation of the previous computing lab. This gave each student three hours of contact teaching per week instead of the previous four and it gave me personally six contact hours instead of the previous five. I had two teaching assistants at all times; the same two for all classes for the same group to provide as much continuity as possible. It proved possible to timetable this arrangement with the two two-hour classes early in the week (one on Monday and one on Tuesday) and two consecutive one-hour classes late in the week (on Friday). This has worked well and I have kept it ever since the second year I taught this module, in 2013–14. It means that nominally students meet the new material for the week on Monday or Tuesday and then attempt exercises on it on Friday. But, since the module is now student paced, I don't try very hard to control what students do when.

From the way that students responded to this module the first year I taught it, I learnt that I had included too much material and also that computing with infinite sets and computational types were too advanced for a first-year module. Infinite sets are covered in Mathematical Structures and the same mathematical notation is used for both finite and infinite sets. When first developing Introduction to Mathematical Computing, I decided to include ways to work with infinite sets in Maple. However, computing with infinite sets is different from computing with finite sets because it is in principle impossible to run through all the elements of an infinite set, so it is necessary to use different computational approaches that introduce an additional layer of difficulty. Some aspects of infinite sets can be implemented very elegantly, in my view, using Maple's very sophisticated computational type system. However, I realised that introducing the Maple type system was also an inessential burden for students learning the basics of computer programming for the first time.

I concluded that including infinite sets and types had been self-indulgent and pedagogically unnecessary, so I decided to drop both topics and spread out the material. I also decided that I was covering some of the material too soon after the students had first met the mathematical ideas in Mathematical Structures. Therefore, I spread the key functions provided by Maple that I initially covered in week 2 over weeks 2 and 3, and I moved computer graphics (plotting) from week 8 to week 5, which meant that I could use graphics much earlier without needing to make a forward reference to a later week. These changes gave a much better density of material and overall balance to the module and I have kept this coverage and ordering of topics ever since the second year I taught the module.

In the second year I taught this module, in 2013–14, I made the module entirely student centred: I did not lecture at all after the first week, when I explained how the module would work and I talked the students through logging in to the computers, accessing QMplus, and starting and running Maple. This change meant that I had to revise my teaching materials significantly: I dropped the references to lectures, since the material was now being delivered week-by-week rather than lecture-by-lecture, and I made it clear that students were expected to work through the module notes in Maple and to try the examples for themselves. Every so often, especially in earlier weeks, I included a "try this" box or an exercise question with a box for the students to enter their answers, followed by my model answer. Maple provides collapsible sections and I put all my model answers in collapsed sections. My intention was that students would attempt the exercises and then look at my answers, either to check their own answers or for some guidance. I included occasional multiple-choice quizzes, again using Maple collapsible sections. Each possible answer was followed by a collapsed explanation of whether it was correct. These quizzes work better in the earlier part of the module and I use them progressively less as the module develops.

I moved the non-assessed exercises out of the separate exercise documents and added them to the end of each week's notes as "synoptic exercises". I included the solutions in collapsed sections. So, apart from the examples in the notes, students have access to lots of examples in the form of exercises that include solutions that are initially hidden. One reason why I continue to make PDF versions of my teaching materials available only a couple of weeks after the Maple versions is that they are equivalent to printed copies, in which all collapsible sections must be expanded to be visible. The inclusion of this extra "interactive" content made my module notes a lot longer and some students have complained that they are now too long. However, I believe that they are clearly structured and students can, for example, easily skip the exercises and/or quizzes if they want, such as when trying to get an overview or when revising for the exam. Whilst I continue to streamline my notes where I can, I also expand sections where I feel students have trouble understanding them, so on balance they are unlikely to get much shorter!

Since I began teaching this module, quite a few students asked me whether they could run Maple on their own private computers. My answer was that they could buy a student version of Maple for around £100, which was the best I could offer within the terms of our Maple licence. But, having moved to a mode of teaching that required students to use Maple for all aspects of this module, I felt it was unsatisfactory for them to have to pay quite a lot of money for their own private copy of Maple – far more than the additional cost for any other module. In the spring of 2014 I was able to negotiate a change to our Maple licence that allows us to provide free copies of Maple to our students. This negotiation was assisted by several fortuitous coincidences. Maplesoft had recently set up their own UK distribution channel and were keen to make contact with universities using Maple; our Maple licence was due for renewal and the options and costs had changed; I also wanted to provide free copies of Maple to the participants in the course for teachers that I was running, sponsored by The Goldsmiths' Company. When I contacted Maplesoft UK about the possibility of them providing free copies of Maple for my Goldsmiths' course, to which they were happy to agree, I also asked them about free copies for my students. They also wanted to discuss the renewal of our licence and were not sure who best to contact. I was able to bring the appropriate parties together and request that we selected an appropriate licence, to which IT Services agreed. The arrangement seems to work well and I hope it will continue to do so.

Attendance in the second year held up better than in the first year and the results of my module evaluation were much better (around 60% overall quality score). However, the comments indicated that students did not like the teaching being entirely student centred. I recall that one student wrote that if he had wanted to be taught in this way he would have taken an Open University course! Therefore, for 2014–15 I introduced mini-lectures and mini-tutorials. I was somewhat reluctant to do this because it meant I had to give the same mini-lecture and mini-tutorial twice, once to each group, but I got used to this. I think one session always goes better than the other for some reason: for example, I might forget to say something important in one of the sessions or I might make a mistake in the first session that I am able to correct in the second session.

Each mini-lecture takes around 30 minutes at the start of a two-hour nominal lecture class and each mini-tutorial takes around 20 minutes at the start of a one-hour nominal tutorial class. I produced mini-lecture slides (using Maple) by deleting everything except a few key ideas from my module notes and I used the Maple slideshow facility to display them. My mini-lectures were clearly popular at least with some students because they asked for copies of my slides. However, I declined to provide them on the basis that everything in them was in the module notes that the students already had and I advised students to produce their own mini-lecture notes as a study guide. In the mini-tutorials I briefly outlined the solutions to the previous week's assessed exercises. Attendance held up as well as it is likely to and the results of my module evaluation were as good as I could reasonably hope they would be for a large compulsory first-year module (around 90% overall quality index).

Further developments that I made for the current academic year, 2015–16, consisted more of polishing for my own satisfaction than directly responding to student feedback. I didn't feel that students were paying much attention to my mini-tutorials, so this year I outlined how to attempt the current feedback exercises instead of discussing the solutions to the previous feedback exercises. I think that students find this more useful because it is providing them with something that they don't already have in some form. However, I have noticed that a lot of students submit as their answers essentially what I have presented to them in the mini-tutorials and don't go on to finish the solutions, even though I believe I make it clear that I am only getting them started.

Moodle provides support for a range of quizzes so I decided that I would move my quizzes into QMplus and simply include hyperlinks to them in my module notes. This proved less satisfactory than I had hoped and I half wish I hadn't tried it. I found it required a lot of work to display the necessary mathematics and Maple input and output in QMplus quizzes. Displaying mathematics is currently not particularly easy in QMplus but I discovered that in MC quiz feedback it did not work properly because the LaTeX input was displayed as well as the rendered mathematical output. My solution was to export my Maple documents to HTML using image files for the mathematics and then import the appropriate image files into QMplus, which looks reasonable but was very tedious to set up. This is something that I want to improve for next academic year. I also discovered that the QMplus quizzes generated a lot of marks in the QMplus gradebook, which are fairly meaningless since the quizzes are formative and entirely optional. To resolve this, I created a Quizzes category in my gradebook, moved all my quiz marks into the Quizzes category and then hid the category.

Another change that I made for this academic year was to introduce formal group work. This was not as a consequence of any direct request by my students but it was part of our general School strategy to improve our students' educational experience. We want to give our students experience of working in groups because we think it will enhance their employability. We also want to improve the effectiveness of our support teaching because it is generally not as well attended as it should be and so appears not to be providing what students want. Students complain about the quality of the feedback that we provide and one reason is limited resources. So current School policy is that students should do their coursework in groups of three and submit one joint set of answers for feedback. This should allow the markers to spend three times longer providing feedback, which should therefore be significantly (around three times) better.

After the first week of teaching, I set up 66 groups and a group choice activity in QMplus and asked my students to get together in groups of three and then all three sign up for the same group. My students were quite reluctant to do this, but after some cajoling and a short "speed dating" session, most but not all students were in groups of three. I set up subsequent assignment managers in QMplus for shared submissions within these small groups, whilst still preserving the marking groups that I had used previously. I ran into some technical problems and the only way I could find to work around them was to appeal to good will from both my students and my markers!

I added a third question to each feedback exercise sheet so that there was nominally one question per student, which meant that I could provide feedback on a wider range of material but the markers had to mark half as much as before rather than only a third. The overall result was not a complete disaster but there is considerable scope for improvement. Most students seemed to find collaborating very difficult and I need to spend more time trying to explain to them how to collaborate. I suggested that each student might take the lead on one of the questions and then all the students get together to discuss all the questions, but in many groups I think each student answered one question without considering the others at all. Some students disengaged from the coursework and the other students in their groups complained that they had an excessive workload. QMplus (Moodle) itself does not really offer any support for group work and I am hoping to use QMplus Hub, our linked portfolio and collaboration facility (Mahara), next year to facilitate student collaboration on group coursework.

Evidence

• A screen shot comparing the QMplus topics for my module in 2012–13 and 2015–16 confirms how I modified the topics that I teach and the order in which I teach them. The latest version of MTH4105 - Introduction to Mathematical Computing should also normally be publicly accessible (but may become less relevant after 2016–17 when I will cease teaching this module).
• The first page of the student evaluations of my module for each of the last four years provides a statistical summary that shows how my overall quality index increased significantly over the first three years and the attendance improved from the first to the second year. My overall quality index went down slightly this year but my attendance went up significantly. My highest score has been for my use of QMplus since this additional question was introduced last year.
• A screen shot of the QMplus topic "Free Maple for student private use" illustrates how this works. This QMplus course area is not publicly accessible.
• I discussed my use of multi-level groups in QMplus in a 10-minute PowerPoint presentation on Managing group assessment and feedback via QMplus at the Queen Mary Learning and Teaching Conference in January 2016.