It’s official! I failed my qualifying exam, and naturally I want to talk about what that means.
Table of Contents
If you’ve been following along, you know all this already, but basically my PhD trajectory looks like this:
- Take ~30 credits
- Pass qualifying exam
- Make dissertation plan
- Pass candidacy exam
- Publish stuff
- Defend dissertation
At this point, I’ve just barely scratched the surface on my PhD journey. In fact, I haven’t even passed qualifying, so I have a long way to go.
Of course, for those of you that don’t know, the qualifying exam is basically three exams that cover topics from three courses I have already taken. In particular, the exam is on Algorithms, Programming Languages, and Operating Systems.
In an effort to study, I put together a series of articles that covered some the topics that I expected to see including:
- The Lisp Programming Language: Interpreter Design (specifically understanding QUOTE and just general execution)
- Minimum Spanning Tree Algorithms (NOT on exam)
- Distributed Mutual Exclusion Using Logical Clocks (specifically FIFO requirement of Lamport’s logical clock)
- Solutions to the Producers-Consumers Problem (NOT on exam)
- Solutions to the Readers-Writers Problem (NOT on exam)
- Understanding Process Synchronization (NOT on exam)
- Understanding the Number Theory Behind Encryption (NOT on exam)
As you can see, I did a terrible job of predicting topics for the exam. Instead, topics that were actually covered included:
- Maximum Flow & Minimum Cut (specifically how to construct a minimum cut from a maximum flow)
- Virtualization (specifically host physical memory, guest physical memory, and guest virtual memory and how to limit host physical memory usage)
- Deadlocks (specifically determine if criteria were enough to protect against deadlocks)
- Axiomatic Semantics (specifically coming up with weakest precondition and applying axioms to prove it)
- Operational Semantics (specifically generating a new rule for do while loops)
- Attribute Grammars (specifically writing an attribute grammar to handle features of imperative languages using a symbol table)
- Dynamic programming (specifically something related to longest common subsequence but was maximum sum increasing subsequence)
- Data Races in Distributed Systems (I don’t remember the problem)
- Database Transactions (specifically determining if logs are serializable using a serialization graph)
Naturally, I’ll need to cover all these gaps. As result, get ready to read many, many more articles related to my studies.
So Close, Yet So Far
After finding out that I had failed, I ran into my advisor who wanted to chat with me about it. Almost immediately, they mentioned that they felt that I should have passed which was a relief. After all, my exam breakdown looked something like the following:
- Algorithms: ~40
- Programming Languages: ~75
- Operating Systems: ~65
Here, I used approximations because I don’t know exactly what my scores were, and I can’t remember what my advisor said. At any rate, the averages were as follows:
- Algorithms: ?
- Programming Languages: ~55
- Operating Systems: ~65
In other words, I absolutely killed that programming languages exam and hit the average for the operating systems exam. As for the algorithms exam, I obviously did poorly, but I’m not sure just how bad it was. Unfortunately, that was the exam that caused me to fail.
As I’ll explain below, it looks like this exam isn’t going away for me either. Moving forward, I’ll need to focus on algorithms big time.
Honestly, I wasn’t really all that surprised that I failed. After all, I had already taken these courses, so I had a feel for how I stood in the department. In particular, I regularly failed the algorithms exams, so I wasn’t really expecting anything to be different.
That said, I did read the textbook which is an absolute first for me. Of course, the professor who wrote this exam has a few favorite topics that aren’t always covered in the book. In fact, several of their problems are related directly to topics only covered in their lectures, so I’ll need to pay attention to the lecture material in the future.
In addition, I think I’m going to have to brush up on my fear of math. Sadly, I haven’t taken a math class since 2014, and I haven’t really needed any of that since—except for this algorithms exam, of course. Maybe if I were more comfortable with math, I’d be doing alright in these theory courses.
Finally, my main takeaway from this is that everything is going to be okay. It’s just an exam. I can’t let it dictate my life.
Plan Moving Forward
As soon as I found out that I had failed the exam, I immediately started thinking about my exit strategy. After all, my plan was to jump departments if I had failed.
Then, something weird happened. My advisor, who had previously supported me in my transition, suddenly wanted me to stick it out and take the exam again. On top of that, they encouraged me to work with another Masters student to put together some research. That way, I’d be in a better position to pass the second time around.
At that point, I thought “well, now what?” Obviously, I don’t want to stick it out, but it seems like that’s going to be the best move for me. As a result, I’m going to need to juggle research, this exam, and the transition at the same time.
Luckily, I got a chance to chat with a few guys who had just made the transition, and they made it seem not so bad. Likewise, I still have funding through the end of this year, so it doesn’t make sense to take the risk right now.
At the moment, the transition timeline looks like next Fall. In the meantime, I’m going to keep grinding, so hopefully I pass the exam in the spring. If not, it’s no big deal. I’ll just have to petition for a Masters.
After that, it’s just a matter of doing some paperwork. For now, I think the best option for me will be to dual enroll. That way, if I don’t get in, I can continue my program in CSE.
Back to Work
With the exam out of the way, I feel oddly relaxed. Of course, I’m sure I’ll be swamped with work shortly, but it’s been nice not to have something looming overhead.
At any rate, hopefully I have better luck next time. For now, I’m just going to keep building up that support network! In the meantime, why don’t you show me some support by becoming a patron or hopping on the mailing list? Likewise, you can always stick around and check out these related articles:
- Looking Back on My First Year of Teaching
- How to Spot a Bad Mentor (Premium)
- Preparing for the Qualifying Exam
With all that said, thanks for sticking around. I appreciate it!
The backbone of any Python program is decision making. In other words, given some input, what should our program do? Today, we'll answer part of that by learning if statements.
The first step in opening a jar is to get a jar. But, how do we do that? Let's let recursion figure that out for us.