Sunday, October 02, 2005

Progress is Good

How about a real entry? In the past few weeks, the thought of sitting down to write something significant just seemed like it would take up too much precious time. As a result, you have been treated to some photos, screenshots and the occasional brief rant about how I am finding school to be quite challenging this semester. I thought that I would sit down, and see what I could come up with in 25 minutes.

School is fascinating. Really, it is. Slowly, but perhaps faster than I am prepared to accept, my classes are delving deeper into the particulars of how a computer does the fascinating things that we expect it to do. Topics that were covered in brief last semester are re-appearing but this time in more detail. It is fascinating to learn about, but makes for some long and challenging course work. The details of a disassembled program don't just pop out to the untrained eye, at first every advance must be meticulously won. Each of my three computer science classes plays to a different level of abstraction, but in interesting ways they are all related.

In programming languages, we are working through design decisions that one must face when creating a new language. Questions such as, what language will we implement our new language with and why? What features should our language support? What will the grammar for our language be? What are the various tradeoffs that we make, or problems that we cause when we choose to implement a given feature in a certain way? Yes, I understand that the sample questions that I just gave are quite vague, but with the hope of keeping all of my readers happy, I thought it better to keep it on a higher level.

In my systems class, we have slowly been peeling back the abstractions. Thinking about bits, and processor instructions has taken up most of the last five weeks. Our current study is focusing on the run-time stack. This class makes me feel most like a hacker, as much of what we have done involves 'tricky' ways to implement functions, figuring out what disassembled code from binary does, and at this moment how to execute buffer overflow attacks on a test server.

Models of computation is by far my most abstract class this semester, but because of my reading this summer, I think that I can see where it is going. DFA's, and NFA's, regular languages, regular expressions, and mathematical proofs have taken up the time in this class. As painful as it is, every computer scientist needs to have some exposure to the mathematical underpinnings of the field. I know that a few of my work associates would really argue with me about that claim, but isn't there something to be gained by knowing exactly what kinds of problems we can't solve? Not to mention why?

My last class, Introduction to Analysis, is helping me to understand why it is that mathematicians never take anything from granted. Every operation, every set, every theory must be carefully constructed, and proved. I am finding that up to this point in the semester I haven't given this class the attention that it properly deserves. These basic proofs that we are working on may be somewhat trivial to the experienced mathematician, but to the undergraduate seeing this for the first time, it is something to study seriously, and even fight with at times. It is really cool in the end when you understand it, but the journey isn't always pleasant.

At school we joke that there is never the time to dedicate to study as we would really like to, we say that it feels like we are constantly putting out fires. There always something on the immediate horizon that must be done. Getting far enough ahead to give each topic its due time is a real challenge. I had to remind myself this weekend that this schedule is of my doing, and that this major is something that I love. I really do enjoy it. At this point, the price may be making sacrifices so that the classes get the study time they need.

Each day I learn something new, this must be progress. Progress is good.

No comments: