CS 3330

This is kind of a hard class to review because I did not find most of the subject material interesting. That said, Luther's enthusiasm for teaching and his seemingly endless knowledge certainly made it more bearable. There is a fair amount of overlap between this class and CS 2150, such as number representation, memory, and writing assembly code. But we ended up learning about pipelining, caching, and virtual memory, along with other new concepts which Bloomfield could not cover. As far as the workload is concerned, I found it fairly reasonable for a CS class. The first homework was way too hard (we got 2 extensions), but the rest of them were more manageable. Luther gave us a practice exam before each test, which was nice, but they often ended up stressing students out very much due to some typos and ambiguous questions. All I can say is that I wish I paid more attention during lectures instead of mindlessly browsing Reddit...

The professor himself is very knowledgeable, not intimidating to talk to during lecture of office hours. The reading quizzes (approximately 2 each week) are pretty difficult so don't underestimate them. The homeworks and labs vary, but they are doable and generally everyone in the class averages very high on those assignments. The tests are beasts, though.

All the CS majors have to take the class, so do your best with it.

The professor: Luther's a nice guy who wants his students to succeed. He is not my favorite professor (there are some pretty fantastic professors), and actually started out as my least favorite CS professor, but with time I realized that he was better than I gave him credit for. He's really smart, and since it was his first time teaching 3330, he had some trouble figuring out what students were having trouble with. The key here is to ask questions. He wants to help you, and once he knows what you need help with, he'll give you a pretty good explanation (and don't pretend you understand his answer if you don't).

The course: I thought it was hard. The textbook has a lot of charts that are fairly difficult to follow/remember the little details of, but you really need to. Luther goes over it stuff in class, but even then it can be hard to pay attention the whole time. The textbook is quite dry so I had trouble getting through it. The reading quizzes were very helpful in focusing attention to key aspects.

The exams: He gives a practice exam before each exam, and it's almost representative. There were always a lot of typos/ambiguities on these, so try to use them as a thinking exercise, and a general diving board into the pool of material you ought to review. The exams usually have some small details, but you'll probably be able to guess what they'll be based on the lectures.

Homeworks: A little tough (especially in the beginning) in my opinion, but with some time and an occasional trip to office hours, you'll be fine.

Labs: Graded on effort. I think you'd have to try to not do well on these.

Luther is not a bad professor. He's one of the most knowledgeable CS professors I've had at UVA, and has an answer to pretty much any (relevant) question you ask him, and he's actually funny (and very witty) once you understand his sense of humor. He seems to genuinely care about his students and wants to always make sure everyone is up to speed, and will spend as much class time as necessary to accomplish that. He reads most of the anonymous feedback he gets before each class, which is always amusing.

The content of the course ranges from fairly interesting to incredibly dull. The textbook is incredibly dry and hard to get through sometimes, but the readings become more manageable as the semester goes on, and the quizzes each week help to force you to understand the material. You will notice the lectures are not very structured, and the half-legible notes/drawings he takes that he posts on the course website will not be very helpful after the fact. However, if you read before class (which you have to do sometimes for quizzes), the lectures are actually helpful in giving you extra exposure and explanation for each topic. Lectures still are incredibly dull most of the time, and the usual 3:30-4:45pm time slot doesn't do it any favors.

If you haven't caught on yet, the book is your friend throughout the course. You'll need it to get your initial exposure to the material, to do quizzes, for reference on the homework assignments, and also to study for tests. It offers the structure and detail that lectures do not.

Homework assignments are hard and time-consuming. I prefer figuring things out myself, but many frequent office hours to get help for these. Piazza is also an excellent resource to get and provide help.

Labs were graded mostly on participation, though they generally were to prepare you for homework, so it's important that you try to understand what you're doing. Some are difficult, but you are able to work with classmates and get help from the TAs.

The tests. The tests are nightmares, quite frankly. You will study hard, understand each topic and how each thing works, but when you take the tests you'll feel like you hadn't studied at all. Yes, they're that bad. A couple things alleviate this though. First, you are provided with practice exams before each. Some are representative of the real thing and some are not. Secondly, Luther has a rubric which I would compare to a predetermined curve, meaning it isn't based on how well the class does. He has some predetermined standard for how well he think a passing student should do, then goes from there. This ended up working out fairly well for me, but I think more reasonable tests with a less generous curve would have represented my understanding somewhat better. I recommend using both the textbook and past quizzes in tandem, as the quizzes help highlight the important points to focus on (but not all of them).

Overall, this class was difficult but somewhat rewarding. I won't give any recommendation since this class is generally taken on a required basis. The time spent outside of class wasn't too bad if you're willing to work on homework on the weekends. Just work hard, go to lecture (and try to pay attention), and study and you will do fine.

This class....hmm it was a learning experience for sure. People usually think they can manage without the textbook for classes and CS courses usually don't even have textbooks but this class the textbook is your best friend. I repeat: THE TEXTBOOK IS YOUR BEST FRIEND! Read every chapter then read it two more times. The quizzes every week are pretty stressful and overtime you usually stop caring about them, but they do get pretty easier. Make sure to pay attention in the beginning, I think it's the hardest material. For the most part, his lectures weren't conducive to my understanding of the material, they were not structured and that personally makes it hard for me to learn. However, he is a cool guy. Go to his office hours! With the homework, there aren't many lengthy assignments like with 2150, but they make you think a little more, but the TA's are wonderful. If you do okay on the exams, but finesse on the homework and labs, you'll be fine.

Course is very dry, Professor tries sometimes, but he's not the best. Unfortunately it's required. I didn't gain much real world skills

Bi-weakly online quizzes that were open note but challenging. Homework took such a long time. I basically lived in office hours just to scrape by in this class. You definitely need the textbook. Required but I don't think I got anything worthwhile out of the course.

Pretty tough class, and I'm still not sure why this course is required. There are definitely some interesting units on optimizing code efficiency and memory, but otherwise I'm not sure when I would ever need this information, although it's good to know. HW/Lab aren't bad but tests and especially quizzes can be brutal. TA's are actually pretty smart though, and the course is very well run.

This review is actually for Luther Tychonievich and Charles Reiss, since in Fall 2016 they both taught the course. I'll give a little rundown of how to succeed:

Quizzes: Read the book carefully, etc. etc. Quizzes are for the whole week, so don't repeat my mistakes and check the schedule to see what the required readings are for the WHOLE WEEK, not just the next class. Easy questions will depend on the definitions of terms in the chapter, e.g. the differences between types of cache misses, or on formulas found in the chapter (many of these for integer representations, caches, some for virtual memory). Generally if you know the definitions and how to do the relevant math you should do alright (by alright I mean better than average, which isn't saying much). Harder questions will rely on concepts, and these can be very challenging. A lot of them seem a little ambiguous: if a question seems ambiguous, ask about it. Often questions were dropped because there were typos or they depended on knowledge that wasn't taught in the course. The same goes for exams, but less often.

Homeworks/Labs: These are pretty much the same thing, lab is usually just a time when you can start your homework. Homeworks can be turned in late, but not labs.

Set up C: Not really a lab, I didn't have to do it because I already had C.
Bomb Lab: Learn how to use the basic debugger commands, you basically need to step through an executable and figure out what input is required to diffuse a "bomb." This is a fun lab. Attendance is required for phase 1.
Coding Labs: It's sufficient to memorize the code here (he gives it to you), but obviously it's better to understand it in case you forget under pressure. strlen is pretty obvious, strsep is basically about understanding pointers and indirection in C; the lists lab is just about understanding different representations of lists at a low level. For both labs you need to present, they are the last labs for which this is necessary. The best way to get 100% is just to practice writing out the code a couple times so you know it, reading is not likely going to cut it.
Bit Puzzles: For this and subsequent labs, you don't actually have to attend, although it is helpful to do so as you can ask the TAs questions. These can be pretty tricky, so it's probably best to start early if you're not a fan of really low level stuff. Understanding masking and how to turn any number into 0, 1, or -1 using ! and ~ are particularly helpful.
HCL: There are about eight of these, you will spend about a month doing this. This is basically implementing a processor in software, using a language designed by Tychonievich. The easiest way to proceed is to use the diagrams for each instruction in section 4.3 (I think) of the text book, that show you what's going on in each stage. For pipelined processors you also have to account for hazards, which is the main difference. They start out easy and get harder, essentially adding on more features. The labs are participation based (just submit something reasonable), and you can resubmit your homeworks if they fail some tests (look in the gradebook and you can see if anything is missing).
Performance: For the rotate lab, cache blocking is enough to get you full credit. Test out multiple block sizes and you will eventually get there. For smooth you mostly want to reduce branch computation, so eliminating function calls, if statements and loops as much as possible gets you on the right track.
Memory Lab: This is participation based, and that's all I remember about it, which tells you something about my motivation at the end of the semester.

Tests: The 2150 strategy of reading past tests is mostly applicable here, with the catch that every semester slightly different topics are covered. For example my semester we apparently went HAM on the pipelined processors, and did less of caches and none of floating point. So if you don't understand a question at all, ask about it and chances are you don't need to know it. As many here have mentioned, the tests are very difficult, but you surprisingly do much better than you thought at the end. Tychonievich (and I suppose Reiss) have an unusually high percentage of "None of the above" style answers, so don't shy away from those. The test questions tend to be easier than the quizzes, actually, since they're not open book. Don't overthink these questions, they aren't usually meant to trick you. And if you don't know an answer to a question, guess, my grade actually improved because I guessed on a question on the final. The curve for these is not based on how other students did, it's usually a square-root curve of your raw score. So for example, you need an 81% raw score to get a 90% actual score (.81^.5 = .9). The final was slightly different, but the same idea.

The URL for the site is http://www.cs.virginia.edu/tychonievich/3330/F2016/schedule.html, so you can read all about it. I'm not sure if Reiss is going to follow the same format for the course, but it should be fairly close since he co-taught with Tychonievich for a semester.