How to Prepare (and When)

This week our operating systems professor surprised us by announcing that he has postponed the exam preparation session planned for mid-December until mid-January. The new date is one week shy of the exam itself. Apparently one person (identity undisclosed) had requested to move the date because (so we hear), for s/he didn’t want to start too early with the exam preparation.

I found that request–but even more so the fact that our professor so readily yielded to it–reasonably bemusing. It sort of flies in the face of what we were being told in the first term tutorial course for Math 101: Exam preparation starts when the term starts.

Let’s leave aside for a moment the fact that the whole idea is inherently illogical, because an earlier date for the preparation session would leave everybody free to start studying later, but not the other way round. In order to start preparing for the operating systems exam, we desperately need input from our professor. He is new at UAS, and is thus teaching operating systems for the first time. That means we have no idea how his exam will look like. For most of the other professors, there are Altklausuren (exams from earlier terms) available on a website maintained by a graduate student. People who have done well in an exam scan their graded solution and upload it there. Needless to say this is an excellent means to get an idea of the structure and requirements of an exam, as well as of the way it will be graded. With most professors, the exams are very similar term after term. In fact, for some courses, particularly those taught by professors from the technical CS study program, they are virtually identical in setup regardless of who teaches the course.

Some professors also hand out exercises complete with solutions, and/or do a mock exam. Our Math 101 / graph theory professor even makes available her own exams from previous terms complete with sample solutions. If the exercises are reasonably close to those of the real exam, and if the mock exams are identical in setup, you can get a really good idea of what is expected of you, where you stand, and what the gaps in your knowledge are; in fact, in the first terms, mock exams also were valuable for giving an impression of how it would feel to be in an actual exam.

Now these means of preparation are in fact somewhat pointless when done early in the term. A mock exam before the term is half over, as our automata theory / logic / algorithms professor is fond of doing, is of limited use as a feedback on your present knowledge and your deficits, for naturally it covers only a fraction of the syllabus for the course. With exercise sheets it’s sort of similar. So doing Altklausuren (usually by covering the solutions and trying to solve the problems independently, then comparing them with the actual solutions–which is why it’s important that you get good solutions by previous term students) as a rule is something we do in the couple of weeks just before the exams. It makes no sense unless you are reasonably confident that you have mastered at least the bulk of the subjects that will likely be covered in the exam.

But that’s exactly the point. To be confident of that a few weeks shy of the exams, you really have to start preparing for them when the term starts. It’s simply hopeless to try cramming the bulk of the material covered in five weekly lectures over 15 weeks into your brain within a couple of weeks just before the exams. Willy-nilly there will always be the gaps in your knowledge closing which needs a concerted effort at term-end: The stuff you never really understood, or the things that are so bloody boring that you could not bring yourself to learn them by rote earlier. But most of the things needed in the exam must already be there in your brain to connect this last-minute material with. You simply can’t make up for a whole term within a few days. At least not if you want something better than a passing grade.

Now in the third term, I am fairly confident of my proven studying techniques. Quite early in the term–in the first couple of weeks in fact–I try to decide for each course whether it’s a crib course or a flashcard course. Typically, math courses are crib courses. They require you to understand rather than to know. For me that means I have to pay attention in class in order to grasp the concepts, for it’s reasonably hopeless for me to understand math solely by looking at formulas. The formulas themselves, or, increasingly, the algorithms, go on the crib, which both our math professors allow us to bring along in the exam: 6 pages in one case, 10 in the other. Within a few days after each math lecture, I go through the slides and write the definitions, formulas, and algorithms on my crib (which actually, in math, is a LaTeX file, for the math symbols). That’s killing two birds with one stone: I am preparing for the exam by making sure I really understand the lecture and by writing my crib. Just before the exam, I edit the crib to see if it’s complete and to bring it to the required length; that means I read it again. In the end, so far it has always turned out that I hardly use the crib at all in the actual exam. It’s simply a great way to force oneself to actually study the material presented in the lecture.

What is not a crib course invariably is a flashcard, i.e. rote-learning, course. I began using flashcards when I felt insecure about the nasty little tests in machine-oriented programming in the second term. They helped me a lot to get boring stuff that did not primarily require understanding, but actually reproducing facts, into my head, and were responsible for my succeeding in both machine-oriented programming and in databases (where we were expected to reproduce things like the actual wording of obscure definitions). I may well have been the one who introduced (electronic) flashcards in our semester group; at least I do not recall having anyone seen using them before I did. Meanwhile, practically everybody who takes studying halfway seriously is using them.

In those courses where no crib is allowed, when I go through the slides again after a lecture, I write definitions etc. on flashcards. Again, this is killing two birds with one stone, for here, too, I have to make sure I understand the material presented in the lecture in order to produce useful flashcards. Well, to a degree at least. With flashcards, it’s always possible to simply learn some things by rote without really fathoming them, though naturally it tends to be more difficult to get things into your head that make no sense. But sometimes–when you make a reasonably effort to get it, and still don’t–it’s the only way.

This term, software engineering and operating systems are the flashcard courses. Software engineering, fortunately, is primarily about understanding the procedures and concepts of software design (which is one of the reasons for its being one of my favorite lectures so far), and there will be an oral exam that will test just these things. At least so I hope. Still, I am under the impression that a certain amount of rote-learning will help to drop exactly the right catch-phrases at the right moments where otherwise one would maybe grope for rather vague circumlocutions. Or to remember things like exactly which software design pattern belong to which group (creational, structural, behavorial), or the dozen or so techniques for requirements analysis. So right now, I have about 200 flashcards for software engineering, though mercifully most of them are rather brief and concise, and I have no great problems learning them.

Which is quite the opposite of what I can say about my nearly 250 cards for operating systems. I find most of the things covered by this course rather arcane and inaccessible–as I said, just the kind of nasty detail I would happily leave to operating system designers to take care of and not bother me with what’s under the hood. Of course, that’s exactly the intercultural problem we all have with the technical CS professors. Amazingly, they find that kind of stuff interesting. Just this week, our OS professor dropped an interactive part into the lecture. In small groups, we were to find out–separately for Linux and Windows–how a C program designer could manipulate the page table (that controls virtual memory) in the operating system. I believe the professor sort of expected us to be excited at the chance of doing something he considered “practical”. But to the degree that any of us even tried to find out (I was one of the few who made a sincere attempt), we all arrived at the same conclusion: Apparently it’s possible to do it, in the sense of there are methods for it. It’s downright scary that any operating system should allow a user to do it, for it has all the potential of breaking the system. And for the life of us we could not imagine a reason why anyone would ever want to do that.

Maybe in keeping with this strange obsession with messing with things better left alone, unfortunately the slides for this lecture often take the approach of covering a subject in great abstract detail, then moving on to the actual implementation. Not only does this make for a great amount of material, a lot of it repetitive. There are always about 60 to 100 slides per lecture, most of them crammed with text. It also means we will be treated to all the theoretical and/or historical ways of solving a problem like, say, having the virtual memory manager select a page for replacement, only to learn then that in Unix and in Windows it’s even more complicated, each version covering at least a single crammed slide. Now try and bring that nicely and logically and in atomic bits onto flashcards. It’s hopeless.

And still, it’s better than going through all the conceivable ways of finding a page frame number from a virtual page number (we’re still in the realm of virtual memory management here), which all go like “the virtual page number divided by the frame size is the actual page number, while the virtual page number modulo the frame size is the offset on the page”, only to learn then that the entire concept is no longer used. Nowadays, you simple take a 32 bit integer, take as many bits as you need (depending on the page size) for the offset, and use the remaining bits for the page number. Simple as that. So why even bother with how it’s not done?

And that’s the problem with this course. Since we have no Altklausuren, no mock exam, and no useful indication as to the setup of the actual exam, we never know whether we will actually need to know all this stuff. And if not all of it, then how much? All we know is that we will not be allowed to bring a crib. So I am taking no chances and every day torture myself with at least 20 minutes of trying to rote-learn things of the kind described above. I really, desperately, need an idea how the actual exam will look like. And not in January. Now.


Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s