End of the Semester

So today is the last day of class for CS 371P, which brings this semester to a close.

I've felt like I've learned a lot this semester, about both C++ and OOP. Considering that I took this class so that I could learn more about these subjects, I definitely am happy with the end results. I was also happy that I became a little more experienced with UML and using Subversion, along with other tools. I think I'll be using at least some of these tools often in the future, so I like to get as much experience as possible while taking classes at UT.

I also had fun working with new people. There can be some downsides to this, but I do like working with others, especially learning what type of techniques they use when programming. I learned at least a few new things to help me in my programming based solely on the fact that I was working with new people this semester. Of course, it was always fun to figure out some topics to talk about on this blog. The Projects and Exams were challenging, but not overly so (at least, not compared to some of my projects/exams for my Operating Systems class).

In conclusion, I'm pretty happy with how the course ended up. In fact, this last semester for me (I'm graduating this semester) has gone really well so far. Hopefully I can continue that success post-UT.

Eclipse

I've been using Eclipse since around the beginning of my second year at UT (almost 3 years ago). I didn't really try any tutorials or anything, so I kind of had to pick up on things on the fly. While it did take me a little while to learn some basic things, I quickly learned to love Eclipse (especially compared to BlueJ, my previous Java IDE).

One thing that bothers me though is that I don't really use some of the nicer features of Eclipse. Although apparently, I'm not doing too badly (e.g., I've been telling some people about the "Correct Indentation" tool). Nevertheless though, I'd definitely like to learn more about the things I never touch (e.g., refactoring). In case others want to learn too, I decided to put some links I just searched for:

http://aspectprogrammer.org/blogs/adrian/2006/02/tips_for_using.html
http://dmy999.com/article/29/using-eclipse-efficiently
http://unitstep.net/blog/2008/02/10/eclipse-the-best-and-only-ide-youll-ever-need/
http://www.intelligentedu.com/blogs/post/best_new_training_sites/3467/best-eclipse-tutorials-and-videos-on-the-web

Some of these may refer to Java only (especially the last one I think), but I think some of it can refer to C++ development as well.

Inheritance

Inheritance isn't really anything new to me. It is one of those things that is drilled into our heads during our first few CS courses (or that's the goal anyway).

But most of that involved inheritance with Java. Simple inheritance, more or less. The type where a class can only inherit from one other class (i.e., only one parent).

But with C++ (and probably other languages), it is evident that inheritance can be much more complicated. Multiple inheritance, protected/private inheritance, double inheritance, virtual inheritance, etc. Some of these really involve drawing a picture of the whole hierarchy to understand what is going on. Granted, some things seem to be affected by odd design choices (e.g., using the same name for instance variables in each class), but it is helpful to know exactly how to work with the classes in these situations. Well...hopefully it is helpful outside of just taking tests about inheritance anyway. :)