This term I took three courses: Operating Systems and Software Engineering II at Oregon State, and Linear Algebra at Portland Community College. This post summarizes my experience with Operating Systems, and offers some advice for people taking the class in the future.
Instructor
Benjamin Brewster
Topics
The course was broken up into four sections, each lasting about two weeks. Here are the main topics covered in each, in order:
- Operating system basics and shell scripts
- The C programming language
- Processes
- Networking
Preparation
Earlier in the program I used to spend the weeks leading up to a new term preparing for the material I would soon be learning. And I’m not the only one – it’s not uncommon to see folks asking on Slack what they can do to prepare for an upcoming class.
I actually had a week between when my internship ended and when this term began, and so I could’ve spent a week learning Vim, or polishing my testing and version control skills, or even doing some advance learning for linear algebra. But I didn’t do any of those things.
Instead, I took a road trip with my wife and daughter to the Alvord Desert in Southeastern Oregon. And that’s the advice I’d give you, too. Take a break! Let school be about school and your breaks be about taking a break.
Programming Environment
This course required working in several programming languages: C, Bash, and Python. Brewster (strongly) recommends (over and over and over) to do all of your programming and testing on the server set aside for the class at Oregon State (it’s called os1), reason being that that’s where your code will be graded so you won’t have to deal with differences between your local environment and that of the graders. Further, we were told that at least one of the assignments (processes) could cause problems on our local machine, so it was best to keep it isolated to that particular server.
I’ve always tested my code on Oregon State’s servers before turning it in for the reason mentioned above, but I was initially hesitant to do my coding there, too. Even though Vim is recommended early in the program, I love all the features and speed that an IDE (like CLion) provides. Still, I gave Vim a try. And I dare say that I came to enjoy using it (for the most part).
There were two things that made Vim worthwhile for me. First was a trick that Nathan Perkins shared that made possible logging into os1 with only one command. That note is here on Piazza. If it doesn’t load for you, ask your instructor or TA about setting this up. I found it incredibly convenient to just open up Terminal (I’m on macOS), type os1, and get to work.
The second thing was having a .vimrc file that made possible things like syntax highlighting and correct tab behavior. You can find the very basic .vimrc file I used here (though note that you’ll probably need to set up Pathogen and lightline.vim for it to behave properly). Place it in the root directory on the server and rename it to .vimrc.
Even though I’m glad I became comfortable programming in Vim, it did have one serious drawback: when the server was bogged down, or when my connection to the server was slow, it was all but impossible to write code. Of course, I could’ve solved this problem by writing code locally and then uploading to os1, but that’s a hassle. This wasn’t an issue very often, but when it was it was maddening. And it probably would’ve been more of a problem had I worked in the evening, when the loads on the server are higher. Instead, I usually code in the early morning.
Assignments
Each block corresponds with a particular assignment, so there are four main assignments in the course. In addition, there is one assignment that requires coding in Python that is not associated with a particular block. Here they are, in order:
- Block 1: Matrix multiplication Bash script
- Block 2: Text-based adventure game in C
- Block 3: Bash-style shell in C
- Block 4: Encryption and decryption with server and client in C
- Python Program: Simple file I/O in Python
The assignments were, in a word, great. The requirements are extremely clear, and the lectures provide basically all of the material that one might need to complete them. That said, I did find myself searching Stack Overflow for quicker or easier ways of doing things.
The easiest of the group was definitely the Python program. This only took me about an hour to complete. The most time-consuming was probably the shell program from Block 3. This was also the most conceptually difficult for me. Even so, the support from the instructor and TAs was excellent. The other programs weren’t significantly easier for me, but I’d written things like them before so I had a better idea of where to get started.
Exams
There was one unproctored, open-note exam at the end of the term. The only preparation I did for it was to combine all the lecture PDFs into one file to make finding information easier. If I hadn’t already watched all of the lectures, I might have done more review.
I scored 177/200 on the final exam. This was lower than I’d expected, but since the instructor does not release correct and incorrect answers, I’m not sure where I went wrong. However, this was still more than good enough to earn an A in the course.
Extra Resources
- Vim tips by John McBride (344 TA)
- Moving around in Vim
- Copying and pasting in Vim
- Search and replace in Vim
- Beej’s Networking Guide
General Strategy
My strategy was to start early, both on the lectures and the assignments. I didn’t work ahead, I just waited until that particular block was open and then got started.
The basic order I went through for each block was as follows:
- Read the assignment description carefully
- Begin watching the lectures
- Begin the assignment
By the second or third day of the block I already had the assignment started and usually the first few lectures done. I think it’s a good idea to work through both simultaneously so that you know what to focus on in the lectures and also so that you don’t get too far behind on the assignment.
I finished most of the assignments a week or more before they were due. This allowed me to focus on my other courses and prevented me from ever feeling like I was falling behind in the course. I never found the course particularly stressful, and this was probably why. Had I waited until I was up against deadlines I don’t think it would’ve been quite so easygoing.
Difficulty and Time Commitment
I’d rank this as the fifth most conceptually difficult course in the program, after Algorithms, Assembly, Data Structures, and Networks. It definitely took up time, but there weren’t a ton of ideas that were difficult to wrap your mind around. The instructor, Benjamin Brewster, deserves a lot of credit for this. He’s an excellent lecturer, very supportive, and is very clearly student-oriented, by which I mean that he seems to care about students’ experience in the course. As a few cases in point, the quality of his lectures is very high, his assignments are well-written, and he and his TAs are very easy to contact for help.
I spent about 85 hours on this course, which works out to about 8.5 hours per week. This number may seem low, but I keep pretty careful track of my time and so I think that it’s accurate. There are about 20 hours of lectures in the course, all of which I watched, so the remaining time was basically all programming the assignments.
To put this in perspective, I spent about 8 hours per week on Software Engineering I, 9 hours per week on Databases, and 9 hours per week on Web Development. Note that this is focused, “nose-in-the-book” study time. I didn’t count the time I spent going to the bathroom, eating lunch, daydreaming, etc.
For what it’s worth, I took two other courses this term (Software Engineering II at Oregon State and Linear Algebra at Portland Community College). I also take care of my two-year-old daughter (along with my wife and in-laws) and volunteer one afternoon per week at a local high school teaching computer science.
Enjoyment
I simply cannot say enough good things about this course. The lectures are excellent, the instructor is excellent, and the assignments are excellent. On top of all of that, the Canvas page for the course is extremely well-organized. This is one of my pet-peeves with many of the other courses in the program (I’m looking at you CS 261!), so this course sets an excellent example.
Speaking of setting examples, I’m glad that I took this course so late in the program. Had I taken it earlier it likely would’ve made me frustrated with the quality of many of the other courses.
Perhaps my favorite part about the course was how simple it was. Not simple in terms of material, but simple in terms of what was expected from students. There aren’t a bunch of little quizzes or little assignments. You’re just responsible for the five assignments listed above and the final. That’s it. I think a lot of the other courses in this program could be improved if the instructors focused their energy on just making a few solid assignments.