Final week

This is it. The last blog post I’ll ever make for one of Professor Downing’s courses, as I have taken both SWE and OOP, and don’t intend to take his summer class. This post will focus on my experience in CS 371p: Object Oriented Programming.

Lectures/Day to day

Professor Downing presents the material well. His lectures are well organized, he provides many examples of what he is talking about, and generally explains things in a clear way.

He calls on people in class, so it’s not always just one person answering every question, and more people get involved with their learning (in theory at least). He also has a quiz every time the class meets, which I have a bit of a love/hate relationship with. I like that it provides a reinforcement for what we previously discussed in class, but they’re also where I’ve lost the most grade points (so far).

Programming Assignments

 

For the most part I thought the programming assignments were fine. The workload was reasonable, and the assignments were fairly instructive and gave an opportunity to try out some things we talked about in class.

I’m not sure I like them all being turned in on hackerrank. The requirement that everything go in to one file is pretty annoying/unrealistic. The hidden tests also led to some annoying bugs with things that were missing from the specification (both Life and Darwin had hackerrank tests which placed multiple things in to one cell on the grid).

I also actively disliked the required length of the acceptance tests for the later assignments for one major reason: the frequency parameter. When you need to make a few thousand lines of tests, you’re going to write a script to generate them, and this will likely just use random values within the acceptable parameters. This is fine, except when your display frequency is once every 250 generations, you’ve officially made a test which doesn’t give very many hints on why it was failed, and this isn’t particularly useful for debugging.

I’m also not sure if Darwin was overly hard, or Life was overly easy, but Darwin was by far the most difficult and time consuming assignment of the course. It might have been nice to talk about the shared pointer before the Life assignment, and require that the cell class be one.

Exams

As of the time of writing, we’ve only had one exam. It was pretty standard — the multiple choice section was similar to the difficulty of the quiz questions, and the programming part was reasonable.

If I could make any change, I would have the hackerrank test cases actually enforce the constraints of the problem, and maybe check some more edge cases. It’s pretty easy to make a solution which appears to work, but actually doesn’t work all that well.

Argument to change the course name

I liked this course, but it seriously needs to have it’s name changed to something like CS 371p: Introduction to C++ Programming. We didn’t really mention objects until we talked about some containers three weeks in, and it was October before we were writing our own classes in lecture. To me, that’s some day one stuff in an OOP class, which I guess should be taught in Java at UT.

That being said, CS 371p: Introduction to C++ Programming is a great course to take. I think learning C++ really helps solidify what many core concepts of other languages mean. Since you have the power to choose if you want something on the stack or on the heap, passed by reference or passed by value, to be immutable or not, have virtual binding or not, etc, you really get a better feeling for what the implications of all of those things are. (Full disclosure: I took some intro to computer science courses in C++, and I think that C++ is an excellent language for intro courses because it presents you with all of these choices).

Actually, changing the class to intro to C++ programming could make the course even better. Maybe we could use new more often and actually experience what it means to have a memory leak (give Valgrind some purpose). We could talk about splitting up your header and implementation (and how you can’t really do that for templated classes). Be mad together that C++ really DOES know the size of your array, but still makes you keep track of it. The list goes on.