And so, my CS241 exam has finished. The exam was pretty easy; significantly harder than the midterm, but still easy. It was like Colin said: They didn’t test anything that requires memorization. If you paid attention in class, did the homework, and kept up with what was going on, it was pretty trivial. However, if you didn’t understand what was going on in class, things got really hairy really fast. Overall, it was a good representation of the course: it began with a little Assembly language coding, then got into DFAs, regular languages, and finally parsing, code generation, and C. It was pretty equal in distribution, meaning that if you knew a little bit of everything, you should do fine. I found it somewhat relaxing, actually, although the last question was a bit of a tough one considering how much C I’ve learned.
And now, a quick course overview:
I don’t really know how to judge this course, to be honest. On one hand, the concepts are really interesting and I think I learned a lot, but on the other hand, I hate compilers and am not touching CS444 with a 10-foot pole. To be honest, I think the course covers too much in too little detail. Most of the course is geared towards teaching about programming languages, which is good, but I think making you write a compiler is the wrong way to approach it. I like the idea of assembly language, but I would have liked to have learned to do more with it. A basic understanding of how Java or C gets converted into runnable code is interesting, but I found the execution a bit…lacking, I suppose. And the fact that C gets taught in the last week of class, expecting you to learn what they teach in about 3 classes and be tested on it for 1/8 of the final exam with very little practice is a bit silly. If it were me, I’d remove C from the course and just have another 2nd year CS course that teaches C (or, even better, a first-year course that would replace CS 125/133/134) in-depth, replacing that material with more course-related stuff. But it’s not me, and I have no say, so I guess whatever works will work.
CS241 is an easy course if you get it. In my opinion, there is no reason as to why CS241 must be a 2nd-year course, aside from the compiler aspect of it. Aside from that, it’s about memory management and the inner workings of the computer, which is really not that complicated. As long as you go by the old CS standbys of “one instruction at a time” and “do not kill the language”, you should do fine, regardless of your CS experience. The problem is when you fail to program properly and forget what certain instructions do that things start to get hairy. The DFA aspect of the course isn’t bad if you stick to small ones. Unfortunately there was a question on the exam that involves a huge immense ridiculous DFA which I guessed at because I didn’t have the patience to walk through it by hand (I did finish the exam half an hour early, so I had the time). Again, if you understand what’s going on in the course material, it’s not bad. If you try to memorize a bunch of stuff, be prepared to do it again next term. But that’s how it is with all CS courses, I’ve found, anyway.
So that’s the brief overview of CS241 in a nutshell. And now I sit here at the end of my first year the way I began; in my frosh T-Shirt and a pair of jeans, at my computer, typing something random. I’m leaving UW in about 2 hours, so I should probably get to packing my things. It’s a bit sad that I won’t have this blog to continue next term, as it’ll be passed off to someone else. And thus ends the blog of Lyle Waldman, First-Year Math Blogger. To all of you attending UW in September, best of luck to you, and to all who aren’t, you really should be.
Signing off,
Lyle Waldman