Spring 2013 Semester Retrospective

I lost this draft right after the semester ended, but spotted it while preparing to write up another project, and am now polishing and posting to continue my habit of posting before/after documentation for my semesters. I spent more of the semester than I probably should have on a variety of enriching distractions (like a 3D Printer), but still did very well at all my course obligations, and the distractions were enriching.

Teaching: CS275: Discrete Mathematics
Early in the semester there were some issues with the primary instructor over style (and my doing some flaky things while making one of the HW keys), but once I adjusted my methods a bit, and results of having two different styles of instruction started to come back, things went very well. My recitations were well attended, students self-reported them as generally useful, the student scores were above expectation (test and HW), there didn’t seem to be any excessive suffering, and my reviews from the primary instructor were good, so victory all around. As much as it is somewhat awkward for me to be teaching what really is a math class as very much not a mathematician, I think the perspective is more useful and relatable to the majority of the students than hearing from someone for whom math comes easily and is and end in itself.

Having TAed the course twice, and taken UK’s undergraduate CS curriculum, I have come to believe there are serious structural issues with the class. To swipe from writing about this previously on my G+:
We spend most of two weeks on probability, that we know every student will have to take at least one full course on, and squish relations/graphs/trees into a week and a half at the end, even though that is the part students are likely to actually use and won’t necessarily be exposed to elsewhere. We have functions at the beginning of the semester, and relations over functions at the end of the semester, which obscures the multiple representations of functions abstraction – as far as I’m concerned that is one of the primary things to get from the class. There are many similar lesser similar structural issues.

It is a very useful class in terms of skills required to be effective working with computers, but we end up spending most of it re-teaching them moderately relevant math tricks.

Taking: Taking: LIN511: Introduction to Computational Linguistics
This was a lot of fun, and I highly recommend it to anyone who likes to play with languages or computer tools in context. It wasn’t terribly difficult, it conveyed a body of useful information, and it was quite entertaining. Most of what we did used DATR and Python/NLTK to implement simple tools.

At one point near the end of the course the instructor did feel the need to apologize for it being too easy for me, but that was sort of missing why I singed up for the class: in addition to firming up some domain knowledge I was there to look at computer tools in context. The tools are quite similar to those we use for programming languages – some are more sophisticated, many are less sophisticated, but they are fundamentally similar, and contextualized very differently, since the languages are interest are generally not regular, context free, deterministic, or even particularly well specified.

It was also very interesting to observe non-computing people interacting with computers. The syntax:sematics:pragmatics relation in programming is much more tightly bound than in natural languages; many of my classmates found the degree of precision required to express things to a computer frustrating. We spent a lot of time on the command line, and there was a lot of difficulty with the idea that actions on the command line are exactly analogous to those performed in a GUI, and even the file/directory abstraction in general. I blame this largely on recent efforts to hide/ruin universal abstractions in computing in favor of apparent magic. Based on the group study sessions preparing for the final, I’m also reasonably sure I could now teach regular expressions to a potato.

For the final group project, my group built a rough prototype part of speech tagger for Persian in Python – this was exciting on several fronts: I don’t speak a word of Persian, and only one member of the group really did. The Persian writing system is very different than our familiar roman alphabet; 32 letters with four different positional forms each (a superset of Arabic), written right-to-left. The most exciting bit for me is that Unicode support in the various tools is “not always perfect,” so I spent some very informative time going over the project with differently buggy text editors, and working around Python and NLTK quirks. The code (including a modified version of one of the NLTK library components) is attached, it isn’t terribly useful as it stands, and isn’t an ideal approach, but it is interesting to look over.

Taking: GS650: Preparing Future Faculty
This turned out exactly as expected – a useful look into the conventions of greater academia, conducted mostly in the form of listening to panels of appropriate speakers, reading appropriate news streams, and writing responses.

For the final project, I went and spent a day with Dr. Jens Hannemann at Kentucky State University. I worked with Dr. Hannemann when he was at UK some years ago, and correctly expected his thoughts on the contrast to be interesting. KSU is… a bit of an overgrown highschool… but the experience was interesting in that it firmed up my growing conception that the faculty roles at regional comprehensive schools are more to my liking than I expected.

Most of the remaining PFF courses look like fun, I will likely take more (possibly enough to end up with the certificate) if my schedules work out to allow it.