06.02
I’ve been re-reading How to get a PhD, which my advisor (Andy Gill) loaned me.
I originally read it last fall at some point, when I was on the fence about switching over from the masters program to the doctoral one. While it’s written from the perspective of the British PhD system, it focuses on the psychological/motivation aspects, so most of it is still relevant.
One thing it brings up several times is the nature of research and “making a novel contribution”. These sections are both motivating and reassuring. I get paralyzed thinking: “I need to do something big and important”, when the reality is more like: “I need to just do something”. General Relativity wasn’t Einstein’s PhD work, and I don’t have to come up with a better functional language compiler for mine (although that would be nice).
Anyway, the book is incredibly motivating to read, and I’m not entirely sure why. Maybe I should snag a copy somewhere and just read a chapter once a month to keep myself focused. I can’t really recommend it enough for anyone considering grad school.
I need to write up a ‘Statement of Purpose’ to officially complete my switch over to the Ph.D. track. I think that is the only bit of administrative work still on my plate this week, so I can look forward to a few uninterrupted days in the not-real world of my brain and coding. After that, I probably should get to work cleaning up my TFP paper for final submission.
I’ve been having a bit of fun attempting to automate the worker/wrapper example from our EECS 800 final. In an attempt to avoid getting bogged down in integration issues I’ve just been writing things from scratch. This has led to spending a lot of time reinventing the wheel when it comes to a typed core language and implementing beta reduction and some form of primitive rule-based rewrites, but I feel like I’m making some decent progress anyway. Hopefully tonight I can push it forward a bit and get something that works in a totally type unsafe way.
Of course, I’ve only been considering this one example of rewriting:
reverse [] = []
reverse (x:xs) = reverse xs ++ [x]
into:
reverse xs = rev_worker xs []
rev_worker [] ys = ys
rev_worker (x:xs) ys = rev_worker xs (x:ys)
So we’ll see what happens when I try to do some other kind of worker/wrapper based optimization. It’s always the second example that shows you where your code is insufficiently generalized.